+ocaml_libvirt_domain_core_dump_job (value domv, value strv)
+{
+ CAMLparam2 (domv, strv);
+#ifndef HAVE_VIRDOMAINCOREDUMPJOB
+ /* Symbol virDomainCoreDumpJob not found at compile time. */
+ not_supported ("virDomainCoreDumpJob");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virDomainCoreDumpJob
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virDomainCoreDumpJob);
+
+ CAMLlocal2 (rv, connv);
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ char *str = String_val (strv);
+ virJobPtr r;
+
+ NONBLOCKING (r = virDomainCoreDumpJob (dom, str, 0));
+ CHECK_ERROR (!r, conn, "virDomainCoreDumpJob");
+
+ connv = Field (domv, 1);
+ rv = Val_job (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+CAMLprim value
+ocaml_libvirt_domain_suspend (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainSuspend (dom));
+ CHECK_ERROR (r == -1, conn, "virDomainSuspend");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_resume (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainResume (dom));
+ CHECK_ERROR (r == -1, conn, "virDomainResume");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_shutdown (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainShutdown (dom));
+ CHECK_ERROR (r == -1, conn, "virDomainShutdown");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_reboot (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainReboot (dom, 0));
+ CHECK_ERROR (r == -1, conn, "virDomainReboot");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_define_xml (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virDomainPtr r;
+
+ NONBLOCKING (r = virDomainDefineXML (conn, str));
+ CHECK_ERROR (!r, conn, "virDomainDefineXML");
+
+ rv = Val_domain (r, connv);
+
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_undefine (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainUndefine (dom));
+ CHECK_ERROR (r == -1, conn, "virDomainUndefine");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_create (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r;
+
+ NONBLOCKING (r = virDomainCreate (dom));
+ CHECK_ERROR (r == -1, conn, "virDomainCreate");
+
+ CAMLreturn (Val_unit);
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRDOMAINCREATEJOB
+extern virJobPtr virDomainCreateJob (virDomainPtr dom, unsigned int flags) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_domain_create_job (value domv)
+{
+ CAMLparam1 (domv);
+#ifndef HAVE_VIRDOMAINCREATEJOB
+ /* Symbol virDomainCreateJob not found at compile time. */
+ not_supported ("virDomainCreateJob");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virDomainCreateJob
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virDomainCreateJob);
+
+ CAMLlocal2 (rv, connv);
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ virJobPtr r;
+
+ NONBLOCKING (r = virDomainCreateJob (dom, 0));
+ CHECK_ERROR (!r, conn, "virDomainCreateJob");
+
+ connv = Field (domv, 1);
+ rv = Val_job (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+CAMLprim value
+ocaml_libvirt_domain_attach_device (value domv, value strv)
+{
+ CAMLparam2 (domv, strv);
+
+ CAMLlocal1 (rv);
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ char *str = String_val (strv);
+ int r;
+
+ NONBLOCKING (r = virDomainAttachDevice (dom, str));
+ CHECK_ERROR (r == -1, conn, "virDomainAttachDevice");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_detach_device (value domv, value strv)
+{
+ CAMLparam2 (domv, strv);
+
+ CAMLlocal1 (rv);
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ char *str = String_val (strv);
+ int r;
+
+ NONBLOCKING (r = virDomainDetachDevice (dom, str));
+ CHECK_ERROR (r == -1, conn, "virDomainDetachDevice");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_get_autostart (value domv)
+{
+ CAMLparam1 (domv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r, b;
+
+ NONBLOCKING (r = virDomainGetAutostart (dom, &b));
+ CHECK_ERROR (r == -1, conn, "virDomainGetAutostart");
+
+ CAMLreturn (b ? Val_true : Val_false);
+}
+
+CAMLprim value
+ocaml_libvirt_domain_set_autostart (value domv, value bv)
+{
+ CAMLparam2 (domv, bv);
+
+ virDomainPtr dom = Domain_val (domv);
+ virConnectPtr conn = Connect_domv (domv);
+ int r, b;
+
+ b = bv == Val_true ? 1 : 0;
+
+ NONBLOCKING (r = virDomainSetAutostart (dom, b));
+ CHECK_ERROR (r == -1, conn, "virDomainSetAutostart");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_network_free (value netv)
+{
+ CAMLparam1 (netv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r;
+
+ NONBLOCKING (r = virNetworkFree (net));
+ CHECK_ERROR (r == -1, conn, "virNetworkFree");
+
+ /* So that we don't double-free in the finalizer: */
+ Network_val (netv) = NULL;
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_network_destroy (value netv)
+{
+ CAMLparam1 (netv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r;
+
+ NONBLOCKING (r = virNetworkDestroy (net));
+ CHECK_ERROR (r == -1, conn, "virNetworkDestroy");
+
+ /* So that we don't double-free in the finalizer: */
+ Network_val (netv) = NULL;
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_network_lookup_by_name (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virNetworkPtr r;
+
+ NONBLOCKING (r = virNetworkLookupByName (conn, str));
+ CHECK_ERROR (!r, conn, "virNetworkLookupByName");
+
+ rv = Val_network (r, connv);
+
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_lookup_by_uuid (value connv, value uuidv)
+{
+ CAMLparam2 (connv, uuidv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ unsigned char *uuid = (unsigned char *) String_val (uuidv);
+ virNetworkPtr r;
+
+ NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid));
+ CHECK_ERROR (!r, conn, "virNetworkLookupByUUID");
+
+ rv = Val_network (r, connv);
+
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virNetworkPtr r;
+
+ NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str));
+ CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString");
+
+ rv = Val_network (r, connv);
+
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_name (value netv)
+{
+ CAMLparam1 (netv);
+
+ CAMLlocal1 (rv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ const char *r;
+
+ NONBLOCKING (r = virNetworkGetName (net));
+ CHECK_ERROR (!r, conn, "virNetworkGetName");
+
+ rv = caml_copy_string (r);
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_xml_desc (value netv)
+{
+ CAMLparam1 (netv);
+
+ CAMLlocal1 (rv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ char *r;
+
+ NONBLOCKING (r = virNetworkGetXMLDesc (net, 0));
+ CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc");
+
+ rv = caml_copy_string (r);
+ free (r);
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_bridge_name (value netv)
+{
+ CAMLparam1 (netv);
+
+ CAMLlocal1 (rv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ char *r;
+
+ NONBLOCKING (r = virNetworkGetBridgeName (net));
+ CHECK_ERROR (!r, conn, "virNetworkGetBridgeName");
+
+ rv = caml_copy_string (r);
+ free (r);
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_uuid (value netv)
+{
+ CAMLparam1 (netv);
+
+ CAMLlocal1 (rv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ unsigned char uuid[VIR_UUID_BUFLEN];
+ int r;
+
+ NONBLOCKING (r = virNetworkGetUUID (net, uuid));
+ CHECK_ERROR (r == -1, conn, "virNetworkGetUUID");
+
+ rv = caml_copy_string ((char *) uuid);
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_uuid_string (value netv)
+{
+ CAMLparam1 (netv);
+
+ CAMLlocal1 (rv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ char uuid[VIR_UUID_STRING_BUFLEN];
+ int r;
+
+ NONBLOCKING (r = virNetworkGetUUIDString (net, uuid));
+ CHECK_ERROR (r == -1, conn, "virNetworkGetUUIDString");
+
+ rv = caml_copy_string (uuid);
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_undefine (value netv)
+{
+ CAMLparam1 (netv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r;
+
+ NONBLOCKING (r = virNetworkUndefine (net));
+ CHECK_ERROR (r == -1, conn, "virNetworkUndefine");
+
+ CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+ocaml_libvirt_network_create_xml (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virNetworkPtr r;
+
+ NONBLOCKING (r = virNetworkCreateXML (conn, str));
+ CHECK_ERROR (!r, conn, "virNetworkCreateXML");
+
+ rv = Val_network (r, connv);
+
+ CAMLreturn (rv);
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRNETWORKCREATEXMLJOB
+extern virJobPtr virNetworkCreateXMLJob (virConnectPtr conn, const char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_network_create_xml_job (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+#ifndef HAVE_VIRNETWORKCREATEXMLJOB
+ /* Symbol virNetworkCreateXMLJob not found at compile time. */
+ not_supported ("virNetworkCreateXMLJob");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virNetworkCreateXMLJob
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virNetworkCreateXMLJob);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virJobPtr r;
+
+ NONBLOCKING (r = virNetworkCreateXMLJob (conn, str));
+ CHECK_ERROR (!r, conn, "virNetworkCreateXMLJob");
+
+ rv = Val_job (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+CAMLprim value
+ocaml_libvirt_network_define_xml (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virNetworkPtr r;
+
+ NONBLOCKING (r = virNetworkDefineXML (conn, str));
+ CHECK_ERROR (!r, conn, "virNetworkDefineXML");
+
+ rv = Val_network (r, connv);
+
+ CAMLreturn (rv);
+}
+
+CAMLprim value
+ocaml_libvirt_network_create (value netv)
+{
+ CAMLparam1 (netv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r;
+
+ NONBLOCKING (r = virNetworkCreate (net));
+ CHECK_ERROR (r == -1, conn, "virNetworkCreate");
+
+ CAMLreturn (Val_unit);
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRNETWORKCREATEJOB
+extern virJobPtr virNetworkCreateJob (virNetworkPtr net) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_network_create_job (value netv)
+{
+ CAMLparam1 (netv);
+#ifndef HAVE_VIRNETWORKCREATEJOB
+ /* Symbol virNetworkCreateJob not found at compile time. */
+ not_supported ("virNetworkCreateJob");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virNetworkCreateJob
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virNetworkCreateJob);
+
+ CAMLlocal2 (rv, connv);
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ virJobPtr r;
+
+ NONBLOCKING (r = virNetworkCreateJob (net));
+ CHECK_ERROR (!r, conn, "virNetworkCreateJob");
+
+ connv = Field (netv, 1);
+ rv = Val_job (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+CAMLprim value
+ocaml_libvirt_network_get_autostart (value netv)
+{
+ CAMLparam1 (netv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r, b;
+
+ NONBLOCKING (r = virNetworkGetAutostart (net, &b));
+ CHECK_ERROR (r == -1, conn, "virNetworkGetAutostart");
+
+ CAMLreturn (b ? Val_true : Val_false);
+}
+
+CAMLprim value
+ocaml_libvirt_network_set_autostart (value netv, value bv)
+{
+ CAMLparam2 (netv, bv);
+
+ virNetworkPtr net = Network_val (netv);
+ virConnectPtr conn = Connect_netv (netv);
+ int r, b;
+
+ b = bv == Val_true ? 1 : 0;
+
+ NONBLOCKING (r = virNetworkSetAutostart (net, b));
+ CHECK_ERROR (r == -1, conn, "virNetworkSetAutostart");
+
+ CAMLreturn (Val_unit);
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLFREE
+extern int virStoragePoolFree (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_free (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLFREE
+ /* Symbol virStoragePoolFree not found at compile time. */
+ not_supported ("virStoragePoolFree");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolFree
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolFree);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolFree (pool));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolFree");
+
+ /* So that we don't double-free in the finalizer: */
+ Pool_val (poolv) = NULL;
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLDESTROY
+extern int virStoragePoolDestroy (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_destroy (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLDESTROY
+ /* Symbol virStoragePoolDestroy not found at compile time. */
+ not_supported ("virStoragePoolDestroy");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolDestroy
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolDestroy);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolDestroy (pool));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolDestroy");
+
+ /* So that we don't double-free in the finalizer: */
+ Pool_val (poolv) = NULL;
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLLOOKUPBYNAME
+extern virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn, const char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+#ifndef HAVE_VIRSTORAGEPOOLLOOKUPBYNAME
+ /* Symbol virStoragePoolLookupByName not found at compile time. */
+ not_supported ("virStoragePoolLookupByName");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolLookupByName
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolLookupByName);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virStoragePoolPtr r;
+
+ NONBLOCKING (r = virStoragePoolLookupByName (conn, str));
+ CHECK_ERROR (!r, conn, "virStoragePoolLookupByName");
+
+ rv = Val_pool (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLLOOKUPBYUUID
+extern virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn, const unsigned char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_lookup_by_uuid (value connv, value uuidv)
+{
+ CAMLparam2 (connv, uuidv);
+#ifndef HAVE_VIRSTORAGEPOOLLOOKUPBYUUID
+ /* Symbol virStoragePoolLookupByUUID not found at compile time. */
+ not_supported ("virStoragePoolLookupByUUID");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolLookupByUUID
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolLookupByUUID);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ unsigned char *uuid = (unsigned char *) String_val (uuidv);
+ virStoragePoolPtr r;
+
+ NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid));
+ CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID");
+
+ rv = Val_pool (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLLOOKUPBYUUIDSTRING
+extern virStoragePoolPtr virStoragePoolLookupByUUIDString (virConnectPtr conn, const char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+#ifndef HAVE_VIRSTORAGEPOOLLOOKUPBYUUIDSTRING
+ /* Symbol virStoragePoolLookupByUUIDString not found at compile time. */
+ not_supported ("virStoragePoolLookupByUUIDString");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolLookupByUUIDString
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolLookupByUUIDString);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virStoragePoolPtr r;
+
+ NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str));
+ CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString");
+
+ rv = Val_pool (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLGETNAME
+extern const char *virStoragePoolGetName (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_get_name (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLGETNAME
+ /* Symbol virStoragePoolGetName not found at compile time. */
+ not_supported ("virStoragePoolGetName");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolGetName
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolGetName);
+
+ CAMLlocal1 (rv);
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ const char *r;
+
+ NONBLOCKING (r = virStoragePoolGetName (pool));
+ CHECK_ERROR (!r, conn, "virStoragePoolGetName");
+
+ rv = caml_copy_string (r);
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLGETXMLDESC
+extern char *virStoragePoolGetXMLDesc (virStoragePoolPtr pool, int flags) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_get_xml_desc (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLGETXMLDESC
+ /* Symbol virStoragePoolGetXMLDesc not found at compile time. */
+ not_supported ("virStoragePoolGetXMLDesc");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolGetXMLDesc
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolGetXMLDesc);
+
+ CAMLlocal1 (rv);
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ char *r;
+
+ NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0));
+ CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc");
+
+ rv = caml_copy_string (r);
+ free (r);
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLGETUUID
+extern int virStoragePoolGetUUID (virStoragePoolPtr pool, unsigned char *) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_get_uuid (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLGETUUID
+ /* Symbol virStoragePoolGetUUID not found at compile time. */
+ not_supported ("virStoragePoolGetUUID");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolGetUUID
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolGetUUID);
+
+ CAMLlocal1 (rv);
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ unsigned char uuid[VIR_UUID_BUFLEN];
+ int r;
+
+ NONBLOCKING (r = virStoragePoolGetUUID (pool, uuid));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUID");
+
+ rv = caml_copy_string ((char *) uuid);
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLGETUUIDSTRING
+extern int virStoragePoolGetUUIDString (virStoragePoolPtr pool, char *) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_get_uuid_string (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLGETUUIDSTRING
+ /* Symbol virStoragePoolGetUUIDString not found at compile time. */
+ not_supported ("virStoragePoolGetUUIDString");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolGetUUIDString
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolGetUUIDString);
+
+ CAMLlocal1 (rv);
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ char uuid[VIR_UUID_STRING_BUFLEN];
+ int r;
+
+ NONBLOCKING (r = virStoragePoolGetUUIDString (pool, uuid));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUIDString");
+
+ rv = caml_copy_string (uuid);
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLCREATEXML
+extern virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn, const char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_create_xml (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+#ifndef HAVE_VIRSTORAGEPOOLCREATEXML
+ /* Symbol virStoragePoolCreateXML not found at compile time. */
+ not_supported ("virStoragePoolCreateXML");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolCreateXML
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolCreateXML);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virStoragePoolPtr r;
+
+ NONBLOCKING (r = virStoragePoolCreateXML (conn, str));
+ CHECK_ERROR (!r, conn, "virStoragePoolCreateXML");
+
+ rv = Val_pool (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLDEFINEXML
+extern virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn, const char *str) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_define_xml (value connv, value strv)
+{
+ CAMLparam2 (connv, strv);
+#ifndef HAVE_VIRSTORAGEPOOLDEFINEXML
+ /* Symbol virStoragePoolDefineXML not found at compile time. */
+ not_supported ("virStoragePoolDefineXML");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolDefineXML
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolDefineXML);
+
+ CAMLlocal1 (rv);
+ virConnectPtr conn = Connect_val (connv);
+ char *str = String_val (strv);
+ virStoragePoolPtr r;
+
+ NONBLOCKING (r = virStoragePoolDefineXML (conn, str));
+ CHECK_ERROR (!r, conn, "virStoragePoolDefineXML");
+
+ rv = Val_pool (r, connv);
+
+ CAMLreturn (rv);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLUNDEFINE
+extern int virStoragePoolUndefine (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_undefine (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLUNDEFINE
+ /* Symbol virStoragePoolUndefine not found at compile time. */
+ not_supported ("virStoragePoolUndefine");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolUndefine
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolUndefine);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolUndefine (pool));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolUndefine");
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLCREATE
+extern int virStoragePoolCreate (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_create (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLCREATE
+ /* Symbol virStoragePoolCreate not found at compile time. */
+ not_supported ("virStoragePoolCreate");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolCreate
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolCreate);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolCreate (pool));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolCreate");
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLSHUTDOWN
+extern int virStoragePoolShutdown (virStoragePoolPtr pool) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_shutdown (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLSHUTDOWN
+ /* Symbol virStoragePoolShutdown not found at compile time. */
+ not_supported ("virStoragePoolShutdown");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolShutdown
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolShutdown);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolShutdown (pool));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolShutdown");
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLREFRESH
+extern int virStoragePoolRefresh (virStoragePoolPtr pool, unsigned int flags) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_refresh (value poolv)
+{
+ CAMLparam1 (poolv);
+#ifndef HAVE_VIRSTORAGEPOOLREFRESH
+ /* Symbol virStoragePoolRefresh not found at compile time. */
+ not_supported ("virStoragePoolRefresh");
+ /* Suppresses a compiler warning. */
+ (void) caml__frame;
+#else
+ /* Check that the symbol virStoragePoolRefresh
+ * is in runtime version of libvirt.
+ */
+ WEAK_SYMBOL_CHECK (virStoragePoolRefresh);
+
+ virStoragePoolPtr pool = Pool_val (poolv);
+ virConnectPtr conn = Connect_polv (poolv);
+ int r;
+
+ NONBLOCKING (r = virStoragePoolRefresh (pool, 0));
+ CHECK_ERROR (r == -1, conn, "virStoragePoolRefresh");
+
+ CAMLreturn (Val_unit);
+#endif
+}
+
+#ifdef HAVE_WEAK_SYMBOLS
+#ifdef HAVE_VIRSTORAGEPOOLGETAUTOSTART
+extern int virStoragePoolGetAutostart (virStoragePoolPtr pool, int *r) __attribute__((weak));
+#endif
+#endif
+
+CAMLprim value
+ocaml_libvirt_storage_pool_get_autostart (value poolv)