libvirt/libvirt_c.c

   1 /* WARNING: THIS FILE IS AUTOMATICALLY GENERATED BY 'generator.pl'.
   2  * Any changes you make to this file may be overwritten.
   3  */
   4
   5 /* OCaml bindings for libvirt.
   6  * (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc.
   7  * http://libvirt.org/
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include <libvirt/libvirt.h>
  31 #include <libvirt/virterror.h>
  32
  33 #include <caml/config.h>
  34 #include <caml/alloc.h>
  35 #include <caml/callback.h>
  36 #include <caml/custom.h>
  37 #include <caml/fail.h>
  38 #include <caml/memory.h>
  39 #include <caml/misc.h>
  40 #include <caml/mlvalues.h>
  41 #include <caml/signals.h>
  42
  43 #include "libvirt_c_prologue.c"
  44
  45 #include "libvirt_c_oneoffs.c"
  46
  47 #ifdef HAVE_WEAK_SYMBOLS
  48 #ifdef HAVE_VIRCONNECTGETHOSTNAME
  49 extern char *virConnectGetHostname (virConnectPtr conn) __attribute__((weak));
  50 #endif
  51 #endif
  52
  53 CAMLprim value
  54 ocaml_libvirt_connect_get_hostname (value connv)
  55 {
  56   CAMLparam1 (connv);
  57 #ifndef HAVE_VIRCONNECTGETHOSTNAME
  58   /* Symbol virConnectGetHostname not found at compile time. */
  59   not_supported ("virConnectGetHostname");
  60   /* Suppresses a compiler warning. */
  61   (void) caml__frame;
  62 #else
  63   /* Check that the symbol virConnectGetHostname
  64    * is in runtime version of libvirt.
  65    */
  66   WEAK_SYMBOL_CHECK (virConnectGetHostname);
  67
  68   CAMLlocal1 (rv);
  69   virConnectPtr conn = Connect_val (connv);
  70   char *r;
  71
  72   NONBLOCKING (r = virConnectGetHostname (conn));
  73   CHECK_ERROR (!r, conn, "virConnectGetHostname");
  74
  75   rv = caml_copy_string (r);
  76   free (r);
  77   CAMLreturn (rv);
  78 #endif
  79 }
  80
  81 #ifdef HAVE_WEAK_SYMBOLS
  82 #ifdef HAVE_VIRCONNECTGETURI
  83 extern char *virConnectGetURI (virConnectPtr conn) __attribute__((weak));
  84 #endif
  85 #endif
  86
  87 CAMLprim value
  88 ocaml_libvirt_connect_get_uri (value connv)
  89 {
  90   CAMLparam1 (connv);
  91 #ifndef HAVE_VIRCONNECTGETURI
  92   /* Symbol virConnectGetURI not found at compile time. */
  93   not_supported ("virConnectGetURI");
  94   /* Suppresses a compiler warning. */
  95   (void) caml__frame;
  96 #else
  97   /* Check that the symbol virConnectGetURI
  98    * is in runtime version of libvirt.
  99    */
 100   WEAK_SYMBOL_CHECK (virConnectGetURI);
 101
 102   CAMLlocal1 (rv);
 103   virConnectPtr conn = Connect_val (connv);
 104   char *r;
 105
 106   NONBLOCKING (r = virConnectGetURI (conn));
 107   CHECK_ERROR (!r, conn, "virConnectGetURI");
 108
 109   rv = caml_copy_string (r);
 110   free (r);
 111   CAMLreturn (rv);
 112 #endif
 113 }
 114
 115 CAMLprim value
 116 ocaml_libvirt_connect_get_type (value connv)
 117 {
 118   CAMLparam1 (connv);
 119
 120   CAMLlocal1 (rv);
 121   virConnectPtr conn = Connect_val (connv);
 122   const char *r;
 123
 124   NONBLOCKING (r = virConnectGetType (conn));
 125   CHECK_ERROR (!r, conn, "virConnectGetType");
 126
 127   rv = caml_copy_string (r);
 128   CAMLreturn (rv);
 129 }
 130
 131 CAMLprim value
 132 ocaml_libvirt_connect_num_of_domains (value connv)
 133 {
 134   CAMLparam1 (connv);
 135
 136   virConnectPtr conn = Connect_val (connv);
 137   int r;
 138
 139   NONBLOCKING (r = virConnectNumOfDomains (conn));
 140   CHECK_ERROR (r == -1, conn, "virConnectNumOfDomains");
 141
 142   CAMLreturn (Val_int (r));
 143 }
 144
 145 CAMLprim value
 146 ocaml_libvirt_connect_list_domains (value connv, value iv)
 147 {
 148   CAMLparam2 (connv, iv);
 149
 150   CAMLlocal1 (rv);
 151   virConnectPtr conn = Connect_val (connv);
 152   int i = Int_val (iv);
 153   int ids[i], r;
 154
 155   NONBLOCKING (r = virConnectListDomains (conn, ids, i));
 156   CHECK_ERROR (r == -1, conn, "virConnectListDomains");
 157
 158   rv = caml_alloc (r, 0);
 159   for (i = 0; i < r; ++i)
 160     Store_field (rv, i, Val_int (ids[i]));
 161
 162   CAMLreturn (rv);
 163 }
 164
 165 CAMLprim value
 166 ocaml_libvirt_connect_num_of_defined_domains (value connv)
 167 {
 168   CAMLparam1 (connv);
 169
 170   virConnectPtr conn = Connect_val (connv);
 171   int r;
 172
 173   NONBLOCKING (r = virConnectNumOfDefinedDomains (conn));
 174   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedDomains");
 175
 176   CAMLreturn (Val_int (r));
 177 }
 178
 179 CAMLprim value
 180 ocaml_libvirt_connect_list_defined_domains (value connv, value iv)
 181 {
 182   CAMLparam2 (connv, iv);
 183
 184   CAMLlocal2 (rv, strv);
 185   virConnectPtr conn = Connect_val (connv);
 186   int i = Int_val (iv);
 187   char *names[i];
 188   int r;
 189
 190   NONBLOCKING (r = virConnectListDefinedDomains (conn, names, i));
 191   CHECK_ERROR (r == -1, conn, "virConnectListDefinedDomains");
 192
 193   rv = caml_alloc (r, 0);
 194   for (i = 0; i < r; ++i) {
 195     strv = caml_copy_string (names[i]);
 196     Store_field (rv, i, strv);
 197     free (names[i]);
 198   }
 199
 200   CAMLreturn (rv);
 201 }
 202
 203 CAMLprim value
 204 ocaml_libvirt_connect_num_of_networks (value connv)
 205 {
 206   CAMLparam1 (connv);
 207
 208   virConnectPtr conn = Connect_val (connv);
 209   int r;
 210
 211   NONBLOCKING (r = virConnectNumOfNetworks (conn));
 212   CHECK_ERROR (r == -1, conn, "virConnectNumOfNetworks");
 213
 214   CAMLreturn (Val_int (r));
 215 }
 216
 217 CAMLprim value
 218 ocaml_libvirt_connect_list_networks (value connv, value iv)
 219 {
 220   CAMLparam2 (connv, iv);
 221
 222   CAMLlocal2 (rv, strv);
 223   virConnectPtr conn = Connect_val (connv);
 224   int i = Int_val (iv);
 225   char *names[i];
 226   int r;
 227
 228   NONBLOCKING (r = virConnectListNetworks (conn, names, i));
 229   CHECK_ERROR (r == -1, conn, "virConnectListNetworks");
 230
 231   rv = caml_alloc (r, 0);
 232   for (i = 0; i < r; ++i) {
 233     strv = caml_copy_string (names[i]);
 234     Store_field (rv, i, strv);
 235     free (names[i]);
 236   }
 237
 238   CAMLreturn (rv);
 239 }
 240
 241 CAMLprim value
 242 ocaml_libvirt_connect_num_of_defined_networks (value connv)
 243 {
 244   CAMLparam1 (connv);
 245
 246   virConnectPtr conn = Connect_val (connv);
 247   int r;
 248
 249   NONBLOCKING (r = virConnectNumOfDefinedNetworks (conn));
 250   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedNetworks");
 251
 252   CAMLreturn (Val_int (r));
 253 }
 254
 255 CAMLprim value
 256 ocaml_libvirt_connect_list_defined_networks (value connv, value iv)
 257 {
 258   CAMLparam2 (connv, iv);
 259
 260   CAMLlocal2 (rv, strv);
 261   virConnectPtr conn = Connect_val (connv);
 262   int i = Int_val (iv);
 263   char *names[i];
 264   int r;
 265
 266   NONBLOCKING (r = virConnectListDefinedNetworks (conn, names, i));
 267   CHECK_ERROR (r == -1, conn, "virConnectListDefinedNetworks");
 268
 269   rv = caml_alloc (r, 0);
 270   for (i = 0; i < r; ++i) {
 271     strv = caml_copy_string (names[i]);
 272     Store_field (rv, i, strv);
 273     free (names[i]);
 274   }
 275
 276   CAMLreturn (rv);
 277 }
 278
 279 #ifdef HAVE_WEAK_SYMBOLS
 280 #ifdef HAVE_VIRCONNECTNUMOFSTORAGEPOOLS
 281 extern int virConnectNumOfStoragePools (virConnectPtr conn) __attribute__((weak));
 282 #endif
 283 #endif
 284
 285 CAMLprim value
 286 ocaml_libvirt_connect_num_of_storage_pools (value connv)
 287 {
 288   CAMLparam1 (connv);
 289 #ifndef HAVE_VIRCONNECTNUMOFSTORAGEPOOLS
 290   /* Symbol virConnectNumOfStoragePools not found at compile time. */
 291   not_supported ("virConnectNumOfStoragePools");
 292   /* Suppresses a compiler warning. */
 293   (void) caml__frame;
 294 #else
 295   /* Check that the symbol virConnectNumOfStoragePools
 296    * is in runtime version of libvirt.
 297    */
 298   WEAK_SYMBOL_CHECK (virConnectNumOfStoragePools);
 299
 300   virConnectPtr conn = Connect_val (connv);
 301   int r;
 302
 303   NONBLOCKING (r = virConnectNumOfStoragePools (conn));
 304   CHECK_ERROR (r == -1, conn, "virConnectNumOfStoragePools");
 305
 306   CAMLreturn (Val_int (r));
 307 #endif
 308 }
 309
 310 #ifdef HAVE_WEAK_SYMBOLS
 311 #ifdef HAVE_VIRCONNECTLISTSTORAGEPOOLS
 312 extern int virConnectListStoragePools (virConnectPtr conn, char **const names, int maxnames) __attribute__((weak));
 313 #endif
 314 #endif
 315
 316 CAMLprim value
 317 ocaml_libvirt_connect_list_storage_pools (value connv, value iv)
 318 {
 319   CAMLparam2 (connv, iv);
 320 #ifndef HAVE_VIRCONNECTLISTSTORAGEPOOLS
 321   /* Symbol virConnectListStoragePools not found at compile time. */
 322   not_supported ("virConnectListStoragePools");
 323   /* Suppresses a compiler warning. */
 324   (void) caml__frame;
 325 #else
 326   /* Check that the symbol virConnectListStoragePools
 327    * is in runtime version of libvirt.
 328    */
 329   WEAK_SYMBOL_CHECK (virConnectListStoragePools);
 330
 331   CAMLlocal2 (rv, strv);
 332   virConnectPtr conn = Connect_val (connv);
 333   int i = Int_val (iv);
 334   char *names[i];
 335   int r;
 336
 337   NONBLOCKING (r = virConnectListStoragePools (conn, names, i));
 338   CHECK_ERROR (r == -1, conn, "virConnectListStoragePools");
 339
 340   rv = caml_alloc (r, 0);
 341   for (i = 0; i < r; ++i) {
 342     strv = caml_copy_string (names[i]);
 343     Store_field (rv, i, strv);
 344     free (names[i]);
 345   }
 346
 347   CAMLreturn (rv);
 348 #endif
 349 }
 350
 351 #ifdef HAVE_WEAK_SYMBOLS
 352 #ifdef HAVE_VIRCONNECTNUMOFDEFINEDSTORAGEPOOLS
 353 extern int virConnectNumOfDefinedStoragePools (virConnectPtr conn) __attribute__((weak));
 354 #endif
 355 #endif
 356
 357 CAMLprim value
 358 ocaml_libvirt_connect_num_of_defined_storage_pools (value connv)
 359 {
 360   CAMLparam1 (connv);
 361 #ifndef HAVE_VIRCONNECTNUMOFDEFINEDSTORAGEPOOLS
 362   /* Symbol virConnectNumOfDefinedStoragePools not found at compile time. */
 363   not_supported ("virConnectNumOfDefinedStoragePools");
 364   /* Suppresses a compiler warning. */
 365   (void) caml__frame;
 366 #else
 367   /* Check that the symbol virConnectNumOfDefinedStoragePools
 368    * is in runtime version of libvirt.
 369    */
 370   WEAK_SYMBOL_CHECK (virConnectNumOfDefinedStoragePools);
 371
 372   virConnectPtr conn = Connect_val (connv);
 373   int r;
 374
 375   NONBLOCKING (r = virConnectNumOfDefinedStoragePools (conn));
 376   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedStoragePools");
 377
 378   CAMLreturn (Val_int (r));
 379 #endif
 380 }
 381
 382 #ifdef HAVE_WEAK_SYMBOLS
 383 #ifdef HAVE_VIRCONNECTLISTDEFINEDSTORAGEPOOLS
 384 extern int virConnectListDefinedStoragePools (virConnectPtr conn, char **const names, int maxnames) __attribute__((weak));
 385 #endif
 386 #endif
 387
 388 CAMLprim value
 389 ocaml_libvirt_connect_list_defined_storage_pools (value connv, value iv)
 390 {
 391   CAMLparam2 (connv, iv);
 392 #ifndef HAVE_VIRCONNECTLISTDEFINEDSTORAGEPOOLS
 393   /* Symbol virConnectListDefinedStoragePools not found at compile time. */
 394   not_supported ("virConnectListDefinedStoragePools");
 395   /* Suppresses a compiler warning. */
 396   (void) caml__frame;
 397 #else
 398   /* Check that the symbol virConnectListDefinedStoragePools
 399    * is in runtime version of libvirt.
 400    */
 401   WEAK_SYMBOL_CHECK (virConnectListDefinedStoragePools);
 402
 403   CAMLlocal2 (rv, strv);
 404   virConnectPtr conn = Connect_val (connv);
 405   int i = Int_val (iv);
 406   char *names[i];
 407   int r;
 408
 409   NONBLOCKING (r = virConnectListDefinedStoragePools (conn, names, i));
 410   CHECK_ERROR (r == -1, conn, "virConnectListDefinedStoragePools");
 411
 412   rv = caml_alloc (r, 0);
 413   for (i = 0; i < r; ++i) {
 414     strv = caml_copy_string (names[i]);
 415     Store_field (rv, i, strv);
 416     free (names[i]);
 417   }
 418
 419   CAMLreturn (rv);
 420 #endif
 421 }
 422
 423 CAMLprim value
 424 ocaml_libvirt_connect_get_capabilities (value connv)
 425 {
 426   CAMLparam1 (connv);
 427
 428   CAMLlocal1 (rv);
 429   virConnectPtr conn = Connect_val (connv);
 430   char *r;
 431
 432   NONBLOCKING (r = virConnectGetCapabilities (conn));
 433   CHECK_ERROR (!r, conn, "virConnectGetCapabilities");
 434
 435   rv = caml_copy_string (r);
 436   free (r);
 437   CAMLreturn (rv);
 438 }
 439
 440 CAMLprim value
 441 ocaml_libvirt_domain_lookup_by_name (value connv, value strv)
 442 {
 443   CAMLparam2 (connv, strv);
 444
 445   CAMLlocal1 (rv);
 446   virConnectPtr conn = Connect_val (connv);
 447   char *str = String_val (strv);
 448   virDomainPtr r;
 449
 450   NONBLOCKING (r = virDomainLookupByName (conn, str));
 451   CHECK_ERROR (!r, conn, "virDomainLookupByName");
 452
 453   rv = Val_domain (r, connv);
 454
 455   CAMLreturn (rv);
 456 }
 457
 458 CAMLprim value
 459 ocaml_libvirt_domain_lookup_by_uuid_string (value connv, value strv)
 460 {
 461   CAMLparam2 (connv, strv);
 462
 463   CAMLlocal1 (rv);
 464   virConnectPtr conn = Connect_val (connv);
 465   char *str = String_val (strv);
 466   virDomainPtr r;
 467
 468   NONBLOCKING (r = virDomainLookupByUUIDString (conn, str));
 469   CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString");
 470
 471   rv = Val_domain (r, connv);
 472
 473   CAMLreturn (rv);
 474 }
 475
 476 CAMLprim value
 477 ocaml_libvirt_domain_get_name (value domv)
 478 {
 479   CAMLparam1 (domv);
 480
 481   CAMLlocal1 (rv);
 482   virDomainPtr dom = Domain_val (domv);
 483   virConnectPtr conn = Connect_domv (domv);
 484   const char *r;
 485
 486   NONBLOCKING (r = virDomainGetName (dom));
 487   CHECK_ERROR (!r, conn, "virDomainGetName");
 488
 489   rv = caml_copy_string (r);
 490   CAMLreturn (rv);
 491 }
 492
 493 CAMLprim value
 494 ocaml_libvirt_domain_get_os_type (value domv)
 495 {
 496   CAMLparam1 (domv);
 497
 498   CAMLlocal1 (rv);
 499   virDomainPtr dom = Domain_val (domv);
 500   virConnectPtr conn = Connect_domv (domv);
 501   char *r;
 502
 503   NONBLOCKING (r = virDomainGetOSType (dom));
 504   CHECK_ERROR (!r, conn, "virDomainGetOSType");
 505
 506   rv = caml_copy_string (r);
 507   free (r);
 508   CAMLreturn (rv);
 509 }
 510
 511 CAMLprim value
 512 ocaml_libvirt_domain_get_xml_desc (value domv)
 513 {
 514   CAMLparam1 (domv);
 515
 516   CAMLlocal1 (rv);
 517   virDomainPtr dom = Domain_val (domv);
 518   virConnectPtr conn = Connect_domv (domv);
 519   char *r;
 520
 521   NONBLOCKING (r = virDomainGetXMLDesc (dom, 0));
 522   CHECK_ERROR (!r, conn, "virDomainGetXMLDesc");
 523
 524   rv = caml_copy_string (r);
 525   free (r);
 526   CAMLreturn (rv);
 527 }
 528
 529 CAMLprim value
 530 ocaml_libvirt_domain_suspend (value domv)
 531 {
 532   CAMLparam1 (domv);
 533
 534   virDomainPtr dom = Domain_val (domv);
 535   virConnectPtr conn = Connect_domv (domv);
 536   int r;
 537
 538   NONBLOCKING (r = virDomainSuspend (dom));
 539   CHECK_ERROR (r == -1, conn, "virDomainSuspend");
 540
 541   CAMLreturn (Val_unit);
 542 }
 543
 544 CAMLprim value
 545 ocaml_libvirt_domain_resume (value domv)
 546 {
 547   CAMLparam1 (domv);
 548
 549   virDomainPtr dom = Domain_val (domv);
 550   virConnectPtr conn = Connect_domv (domv);
 551   int r;
 552
 553   NONBLOCKING (r = virDomainResume (dom));
 554   CHECK_ERROR (r == -1, conn, "virDomainResume");
 555
 556   CAMLreturn (Val_unit);
 557 }
 558
 559 CAMLprim value
 560 ocaml_libvirt_domain_shutdown (value domv)
 561 {
 562   CAMLparam1 (domv);
 563
 564   virDomainPtr dom = Domain_val (domv);
 565   virConnectPtr conn = Connect_domv (domv);
 566   int r;
 567
 568   NONBLOCKING (r = virDomainShutdown (dom));
 569   CHECK_ERROR (r == -1, conn, "virDomainShutdown");
 570
 571   CAMLreturn (Val_unit);
 572 }
 573
 574 CAMLprim value
 575 ocaml_libvirt_domain_reboot (value domv)
 576 {
 577   CAMLparam1 (domv);
 578
 579   virDomainPtr dom = Domain_val (domv);
 580   virConnectPtr conn = Connect_domv (domv);
 581   int r;
 582
 583   NONBLOCKING (r = virDomainReboot (dom, 0));
 584   CHECK_ERROR (r == -1, conn, "virDomainReboot");
 585
 586   CAMLreturn (Val_unit);
 587 }
 588
 589 CAMLprim value
 590 ocaml_libvirt_domain_undefine (value domv)
 591 {
 592   CAMLparam1 (domv);
 593
 594   virDomainPtr dom = Domain_val (domv);
 595   virConnectPtr conn = Connect_domv (domv);
 596   int r;
 597
 598   NONBLOCKING (r = virDomainUndefine (dom));
 599   CHECK_ERROR (r == -1, conn, "virDomainUndefine");
 600
 601   CAMLreturn (Val_unit);
 602 }
 603
 604 CAMLprim value
 605 ocaml_libvirt_domain_create (value domv)
 606 {
 607   CAMLparam1 (domv);
 608
 609   virDomainPtr dom = Domain_val (domv);
 610   virConnectPtr conn = Connect_domv (domv);
 611   int r;
 612
 613   NONBLOCKING (r = virDomainCreate (dom));
 614   CHECK_ERROR (r == -1, conn, "virDomainCreate");
 615
 616   CAMLreturn (Val_unit);
 617 }
 618
 619 CAMLprim value
 620 ocaml_libvirt_network_lookup_by_name (value connv, value strv)
 621 {
 622   CAMLparam2 (connv, strv);
 623
 624   CAMLlocal1 (rv);
 625   virConnectPtr conn = Connect_val (connv);
 626   char *str = String_val (strv);
 627   virNetworkPtr r;
 628
 629   NONBLOCKING (r = virNetworkLookupByName (conn, str));
 630   CHECK_ERROR (!r, conn, "virNetworkLookupByName");
 631
 632   rv = Val_network (r, connv);
 633
 634   CAMLreturn (rv);
 635 }
 636
 637 CAMLprim value
 638 ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv)
 639 {
 640   CAMLparam2 (connv, strv);
 641
 642   CAMLlocal1 (rv);
 643   virConnectPtr conn = Connect_val (connv);
 644   char *str = String_val (strv);
 645   virNetworkPtr r;
 646
 647   NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str));
 648   CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString");
 649
 650   rv = Val_network (r, connv);
 651
 652   CAMLreturn (rv);
 653 }
 654
 655 CAMLprim value
 656 ocaml_libvirt_network_get_name (value netv)
 657 {
 658   CAMLparam1 (netv);
 659
 660   CAMLlocal1 (rv);
 661   virNetworkPtr net = Network_val (netv);
 662   virConnectPtr conn = Connect_netv (netv);
 663   const char *r;
 664
 665   NONBLOCKING (r = virNetworkGetName (net));
 666   CHECK_ERROR (!r, conn, "virNetworkGetName");
 667
 668   rv = caml_copy_string (r);
 669   CAMLreturn (rv);
 670 }
 671
 672 CAMLprim value
 673 ocaml_libvirt_network_get_xml_desc (value netv)
 674 {
 675   CAMLparam1 (netv);
 676
 677   CAMLlocal1 (rv);
 678   virNetworkPtr net = Network_val (netv);
 679   virConnectPtr conn = Connect_netv (netv);
 680   char *r;
 681
 682   NONBLOCKING (r = virNetworkGetXMLDesc (net, 0));
 683   CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc");
 684
 685   rv = caml_copy_string (r);
 686   free (r);
 687   CAMLreturn (rv);
 688 }
 689
 690 CAMLprim value
 691 ocaml_libvirt_network_get_bridge_name (value netv)
 692 {
 693   CAMLparam1 (netv);
 694
 695   CAMLlocal1 (rv);
 696   virNetworkPtr net = Network_val (netv);
 697   virConnectPtr conn = Connect_netv (netv);
 698   char *r;
 699
 700   NONBLOCKING (r = virNetworkGetBridgeName (net));
 701   CHECK_ERROR (!r, conn, "virNetworkGetBridgeName");
 702
 703   rv = caml_copy_string (r);
 704   free (r);
 705   CAMLreturn (rv);
 706 }
 707
 708 CAMLprim value
 709 ocaml_libvirt_network_undefine (value netv)
 710 {
 711   CAMLparam1 (netv);
 712
 713   virNetworkPtr net = Network_val (netv);
 714   virConnectPtr conn = Connect_netv (netv);
 715   int r;
 716
 717   NONBLOCKING (r = virNetworkUndefine (net));
 718   CHECK_ERROR (r == -1, conn, "virNetworkUndefine");
 719
 720   CAMLreturn (Val_unit);
 721 }
 722
 723 CAMLprim value
 724 ocaml_libvirt_network_create (value netv)
 725 {
 726   CAMLparam1 (netv);
 727
 728   virNetworkPtr net = Network_val (netv);
 729   virConnectPtr conn = Connect_netv (netv);
 730   int r;
 731
 732   NONBLOCKING (r = virNetworkCreate (net));
 733   CHECK_ERROR (r == -1, conn, "virNetworkCreate");
 734
 735   CAMLreturn (Val_unit);
 736 }
 737
 738 #ifdef HAVE_WEAK_SYMBOLS
 739 #ifdef HAVE_VIRSTORAGEPOOLLOOKUPBYNAME
 740 extern virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn dom) __attribute__((weak));
 741 #endif
 742 #endif
 743
 744 CAMLprim value
 745 ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv)
 746 {
 747   CAMLparam2 (connv, strv);
 748 #ifndef HAVE_VIRSTORAGEPOOLLOOKUPBYNAME
 749   /* Symbol virStoragePoolLookupByName not found at compile time. */
 750   not_supported ("virStoragePoolLookupByName");
 751   /* Suppresses a compiler warning. */
 752   (void) caml__frame;
 753 #else
 754   /* Check that the symbol virStoragePoolLookupByName
 755    * is in runtime version of libvirt.
 756    */
 757   WEAK_SYMBOL_CHECK (virStoragePoolLookupByName);
 758
 759   CAMLlocal1 (rv);
 760   virConnectPtr conn = Connect_val (connv);
 761   char *str = String_val (strv);
 762   virStoragePoolPtr r;
 763
 764   NONBLOCKING (r = virStoragePoolLookupByName (conn, str));
 765   CHECK_ERROR (!r, conn, "virStoragePoolLookupByName");
 766
 767   rv = Val_pool (r, connv);
 768
 769   CAMLreturn (rv);
 770 #endif
 771 }
 772
 773 #ifdef HAVE_WEAK_SYMBOLS
 774 #ifdef HAVE_VIRSTORAGEPOOLLOOKUPBYUUIDSTRING
 775 extern virStoragePoolPtr virStoragePoolLookupByUUIDString (virConnectPtr conn dom) __attribute__((weak));
 776 #endif
 777 #endif
 778
 779 CAMLprim value
 780 ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv)
 781 {
 782   CAMLparam2 (connv, strv);
 783 #ifndef HAVE_VIRSTORAGEPOOLLOOKUPBYUUIDSTRING
 784   /* Symbol virStoragePoolLookupByUUIDString not found at compile time. */
 785   not_supported ("virStoragePoolLookupByUUIDString");
 786   /* Suppresses a compiler warning. */
 787   (void) caml__frame;
 788 #else
 789   /* Check that the symbol virStoragePoolLookupByUUIDString
 790    * is in runtime version of libvirt.
 791    */
 792   WEAK_SYMBOL_CHECK (virStoragePoolLookupByUUIDString);
 793
 794   CAMLlocal1 (rv);
 795   virConnectPtr conn = Connect_val (connv);
 796   char *str = String_val (strv);
 797   virStoragePoolPtr r;
 798
 799   NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str));
 800   CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString");
 801
 802   rv = Val_pool (r, connv);
 803
 804   CAMLreturn (rv);
 805 #endif
 806 }
 807
 808 #ifdef HAVE_WEAK_SYMBOLS
 809 #ifdef HAVE_VIRSTORAGEPOOLGETNAME
 810 extern const char *virStoragePoolGetName (virStoragePoolPtr pool) __attribute__((weak));
 811 #endif
 812 #endif
 813
 814 CAMLprim value
 815 ocaml_libvirt_storage_pool_get_name (value poolv)
 816 {
 817   CAMLparam1 (poolv);
 818 #ifndef HAVE_VIRSTORAGEPOOLGETNAME
 819   /* Symbol virStoragePoolGetName not found at compile time. */
 820   not_supported ("virStoragePoolGetName");
 821   /* Suppresses a compiler warning. */
 822   (void) caml__frame;
 823 #else
 824   /* Check that the symbol virStoragePoolGetName
 825    * is in runtime version of libvirt.
 826    */
 827   WEAK_SYMBOL_CHECK (virStoragePoolGetName);
 828
 829   CAMLlocal1 (rv);
 830   virStoragePoolPtr pool = Pool_val (poolv);
 831   virConnectPtr conn = Connect_polv (poolv);
 832   const char *r;
 833
 834   NONBLOCKING (r = virStoragePoolGetName (pool));
 835   CHECK_ERROR (!r, conn, "virStoragePoolGetName");
 836
 837   rv = caml_copy_string (r);
 838   CAMLreturn (rv);
 839 #endif
 840 }
 841
 842 #ifdef HAVE_WEAK_SYMBOLS
 843 #ifdef HAVE_VIRSTORAGEPOOLGETXMLDESC
 844 extern char *virStoragePoolGetXMLDesc (virStoragePoolPtr pool, int flags) __attribute__((weak));
 845 #endif
 846 #endif
 847
 848 CAMLprim value
 849 ocaml_libvirt_storage_pool_get_xml_desc (value poolv)
 850 {
 851   CAMLparam1 (poolv);
 852 #ifndef HAVE_VIRSTORAGEPOOLGETXMLDESC
 853   /* Symbol virStoragePoolGetXMLDesc not found at compile time. */
 854   not_supported ("virStoragePoolGetXMLDesc");
 855   /* Suppresses a compiler warning. */
 856   (void) caml__frame;
 857 #else
 858   /* Check that the symbol virStoragePoolGetXMLDesc
 859    * is in runtime version of libvirt.
 860    */
 861   WEAK_SYMBOL_CHECK (virStoragePoolGetXMLDesc);
 862
 863   CAMLlocal1 (rv);
 864   virStoragePoolPtr pool = Pool_val (poolv);
 865   virConnectPtr conn = Connect_polv (poolv);
 866   char *r;
 867
 868   NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0));
 869   CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc");
 870
 871   rv = caml_copy_string (r);
 872   free (r);
 873   CAMLreturn (rv);
 874 #endif
 875 }
 876
 877 #ifdef HAVE_WEAK_SYMBOLS
 878 #ifdef HAVE_VIRSTORAGEPOOLUNDEFINE
 879 extern char *virStoragePoolUndefine (virStoragePoolPtr pool) __attribute__((weak));
 880 #endif
 881 #endif
 882
 883 CAMLprim value
 884 ocaml_libvirt_storage_pool_undefine (value poolv)
 885 {
 886   CAMLparam1 (poolv);
 887 #ifndef HAVE_VIRSTORAGEPOOLUNDEFINE
 888   /* Symbol virStoragePoolUndefine not found at compile time. */
 889   not_supported ("virStoragePoolUndefine");
 890   /* Suppresses a compiler warning. */
 891   (void) caml__frame;
 892 #else
 893   /* Check that the symbol virStoragePoolUndefine
 894    * is in runtime version of libvirt.
 895    */
 896   WEAK_SYMBOL_CHECK (virStoragePoolUndefine);
 897
 898   CAMLlocal1 (rv);
 899   virStoragePoolPtr pool = Pool_val (poolv);
 900   virConnectPtr conn = Connect_polv (poolv);
 901   char *r;
 902
 903   NONBLOCKING (r = virStoragePoolUndefine (pool));
 904   CHECK_ERROR (!r, conn, "virStoragePoolUndefine");
 905
 906   rv = caml_copy_string (r);
 907   free (r);
 908   CAMLreturn (rv);
 909 #endif
 910 }
 911
 912 #ifdef HAVE_WEAK_SYMBOLS
 913 #ifdef HAVE_VIRSTORAGEPOOLCREATE
 914 extern char *virStoragePoolCreate (virStoragePoolPtr pool) __attribute__((weak));
 915 #endif
 916 #endif
 917
 918 CAMLprim value
 919 ocaml_libvirt_storage_pool_create (value poolv)
 920 {
 921   CAMLparam1 (poolv);
 922 #ifndef HAVE_VIRSTORAGEPOOLCREATE
 923   /* Symbol virStoragePoolCreate not found at compile time. */
 924   not_supported ("virStoragePoolCreate");
 925   /* Suppresses a compiler warning. */
 926   (void) caml__frame;
 927 #else
 928   /* Check that the symbol virStoragePoolCreate
 929    * is in runtime version of libvirt.
 930    */
 931   WEAK_SYMBOL_CHECK (virStoragePoolCreate);
 932
 933   CAMLlocal1 (rv);
 934   virStoragePoolPtr pool = Pool_val (poolv);
 935   virConnectPtr conn = Connect_polv (poolv);
 936   char *r;
 937
 938   NONBLOCKING (r = virStoragePoolCreate (pool));
 939   CHECK_ERROR (!r, conn, "virStoragePoolCreate");
 940
 941   rv = caml_copy_string (r);
 942   free (r);
 943   CAMLreturn (rv);
 944 #endif
 945 }
 946
 947 #ifdef HAVE_WEAK_SYMBOLS
 948 #ifdef HAVE_VIRSTORAGEPOOLSHUTDOWN
 949 extern char *virStoragePoolShutdown (virStoragePoolPtr pool) __attribute__((weak));
 950 #endif
 951 #endif
 952
 953 CAMLprim value
 954 ocaml_libvirt_storage_pool_shutdown (value poolv)
 955 {
 956   CAMLparam1 (poolv);
 957 #ifndef HAVE_VIRSTORAGEPOOLSHUTDOWN
 958   /* Symbol virStoragePoolShutdown not found at compile time. */
 959   not_supported ("virStoragePoolShutdown");
 960   /* Suppresses a compiler warning. */
 961   (void) caml__frame;
 962 #else
 963   /* Check that the symbol virStoragePoolShutdown
 964    * is in runtime version of libvirt.
 965    */
 966   WEAK_SYMBOL_CHECK (virStoragePoolShutdown);
 967
 968   CAMLlocal1 (rv);
 969   virStoragePoolPtr pool = Pool_val (poolv);
 970   virConnectPtr conn = Connect_polv (poolv);
 971   char *r;
 972
 973   NONBLOCKING (r = virStoragePoolShutdown (pool));
 974   CHECK_ERROR (!r, conn, "virStoragePoolShutdown");
 975
 976   rv = caml_copy_string (r);
 977   free (r);
 978   CAMLreturn (rv);
 979 #endif
 980 }
 981
 982 #ifdef HAVE_WEAK_SYMBOLS
 983 #ifdef HAVE_VIRSTORAGEPOOLREFRESH
 984 extern char *virStoragePoolRefresh (virStoragePoolPtr pool, int flags) __attribute__((weak));
 985 #endif
 986 #endif
 987
 988 CAMLprim value
 989 ocaml_libvirt_storage_pool_refresh (value poolv)
 990 {
 991   CAMLparam1 (poolv);
 992 #ifndef HAVE_VIRSTORAGEPOOLREFRESH
 993   /* Symbol virStoragePoolRefresh not found at compile time. */
 994   not_supported ("virStoragePoolRefresh");
 995   /* Suppresses a compiler warning. */
 996   (void) caml__frame;
 997 #else
 998   /* Check that the symbol virStoragePoolRefresh
 999    * is in runtime version of libvirt.
1000    */
1001   WEAK_SYMBOL_CHECK (virStoragePoolRefresh);
1002
1003   CAMLlocal1 (rv);
1004   virStoragePoolPtr pool = Pool_val (poolv);
1005   virConnectPtr conn = Connect_polv (poolv);
1006   char *r;
1007
1008   NONBLOCKING (r = virStoragePoolRefresh (pool, 0));
1009   CHECK_ERROR (!r, conn, "virStoragePoolRefresh");
1010
1011   rv = caml_copy_string (r);
1012   free (r);
1013   CAMLreturn (rv);
1014 #endif
1015 }
1016
1017 #ifdef HAVE_WEAK_SYMBOLS
1018 #ifdef HAVE_VIRSTORAGEVOLLOOKUPBYNAME
1019 extern virStorageVolPtr virStorageVolLookupByName (virConnectPtr conn dom) __attribute__((weak));
1020 #endif
1021 #endif
1022
1023 CAMLprim value
1024 ocaml_libvirt_storage_vol_lookup_by_name (value connv, value strv)
1025 {
1026   CAMLparam2 (connv, strv);
1027 #ifndef HAVE_VIRSTORAGEVOLLOOKUPBYNAME
1028   /* Symbol virStorageVolLookupByName not found at compile time. */
1029   not_supported ("virStorageVolLookupByName");
1030   /* Suppresses a compiler warning. */
1031   (void) caml__frame;
1032 #else
1033   /* Check that the symbol virStorageVolLookupByName
1034    * is in runtime version of libvirt.
1035    */
1036   WEAK_SYMBOL_CHECK (virStorageVolLookupByName);
1037
1038   CAMLlocal1 (rv);
1039   virConnectPtr conn = Connect_val (connv);
1040   char *str = String_val (strv);
1041   virStorageVolPtr r;
1042
1043   NONBLOCKING (r = virStorageVolLookupByName (conn, str));
1044   CHECK_ERROR (!r, conn, "virStorageVolLookupByName");
1045
1046   rv = Val_volume (r, connv);
1047
1048   CAMLreturn (rv);
1049 #endif
1050 }
1051
1052 #ifdef HAVE_WEAK_SYMBOLS
1053 #ifdef HAVE_VIRSTORAGEVOLLOOKUPBYKEY
1054 extern virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn dom) __attribute__((weak));
1055 #endif
1056 #endif
1057
1058 CAMLprim value
1059 ocaml_libvirt_storage_vol_lookup_by_key (value connv, value strv)
1060 {
1061   CAMLparam2 (connv, strv);
1062 #ifndef HAVE_VIRSTORAGEVOLLOOKUPBYKEY
1063   /* Symbol virStorageVolLookupByKey not found at compile time. */
1064   not_supported ("virStorageVolLookupByKey");
1065   /* Suppresses a compiler warning. */
1066   (void) caml__frame;
1067 #else
1068   /* Check that the symbol virStorageVolLookupByKey
1069    * is in runtime version of libvirt.
1070    */
1071   WEAK_SYMBOL_CHECK (virStorageVolLookupByKey);
1072
1073   CAMLlocal1 (rv);
1074   virConnectPtr conn = Connect_val (connv);
1075   char *str = String_val (strv);
1076   virStorageVolPtr r;
1077
1078   NONBLOCKING (r = virStorageVolLookupByKey (conn, str));
1079   CHECK_ERROR (!r, conn, "virStorageVolLookupByKey");
1080
1081   rv = Val_volume (r, connv);
1082
1083   CAMLreturn (rv);
1084 #endif
1085 }
1086
1087 #ifdef HAVE_WEAK_SYMBOLS
1088 #ifdef HAVE_VIRSTORAGEVOLLOOKUPBYPATH
1089 extern virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn dom) __attribute__((weak));
1090 #endif
1091 #endif
1092
1093 CAMLprim value
1094 ocaml_libvirt_storage_vol_lookup_by_path (value connv, value strv)
1095 {
1096   CAMLparam2 (connv, strv);
1097 #ifndef HAVE_VIRSTORAGEVOLLOOKUPBYPATH
1098   /* Symbol virStorageVolLookupByPath not found at compile time. */
1099   not_supported ("virStorageVolLookupByPath");
1100   /* Suppresses a compiler warning. */
1101   (void) caml__frame;
1102 #else
1103   /* Check that the symbol virStorageVolLookupByPath
1104    * is in runtime version of libvirt.
1105    */
1106   WEAK_SYMBOL_CHECK (virStorageVolLookupByPath);
1107
1108   CAMLlocal1 (rv);
1109   virConnectPtr conn = Connect_val (connv);
1110   char *str = String_val (strv);
1111   virStorageVolPtr r;
1112
1113   NONBLOCKING (r = virStorageVolLookupByPath (conn, str));
1114   CHECK_ERROR (!r, conn, "virStorageVolLookupByPath");
1115
1116   rv = Val_volume (r, connv);
1117
1118   CAMLreturn (rv);
1119 #endif
1120 }
1121
1122 #ifdef HAVE_WEAK_SYMBOLS
1123 #ifdef HAVE_VIRSTORAGEVOLGETXMLDESC
1124 extern char *virStorageVolGetXMLDesc (virStoragePoolPtr pool, int flags) __attribute__((weak));
1125 #endif
1126 #endif
1127
1128 CAMLprim value
1129 ocaml_libvirt_storage_vol_get_xml_desc (value poolv)
1130 {
1131   CAMLparam1 (poolv);
1132 #ifndef HAVE_VIRSTORAGEVOLGETXMLDESC
1133   /* Symbol virStorageVolGetXMLDesc not found at compile time. */
1134   not_supported ("virStorageVolGetXMLDesc");
1135   /* Suppresses a compiler warning. */
1136   (void) caml__frame;
1137 #else
1138   /* Check that the symbol virStorageVolGetXMLDesc
1139    * is in runtime version of libvirt.
1140    */
1141   WEAK_SYMBOL_CHECK (virStorageVolGetXMLDesc);
1142
1143   CAMLlocal1 (rv);
1144   virStoragePoolPtr pool = Pool_val (poolv);
1145   virConnectPtr conn = Connect_polv (poolv);
1146   char *r;
1147
1148   NONBLOCKING (r = virStorageVolGetXMLDesc (pool, 0));
1149   CHECK_ERROR (!r, conn, "virStorageVolGetXMLDesc");
1150
1151   rv = caml_copy_string (r);
1152   free (r);
1153   CAMLreturn (rv);
1154 #endif
1155 }
1156
1157 #ifdef HAVE_WEAK_SYMBOLS
1158 #ifdef HAVE_VIRSTORAGEVOLGETPATH
1159 extern char *virStorageVolGetPath (virStoragePoolPtr pool) __attribute__((weak));
1160 #endif
1161 #endif
1162
1163 CAMLprim value
1164 ocaml_libvirt_storage_vol_get_path (value poolv)
1165 {
1166   CAMLparam1 (poolv);
1167 #ifndef HAVE_VIRSTORAGEVOLGETPATH
1168   /* Symbol virStorageVolGetPath not found at compile time. */
1169   not_supported ("virStorageVolGetPath");
1170   /* Suppresses a compiler warning. */
1171   (void) caml__frame;
1172 #else
1173   /* Check that the symbol virStorageVolGetPath
1174    * is in runtime version of libvirt.
1175    */
1176   WEAK_SYMBOL_CHECK (virStorageVolGetPath);
1177
1178   CAMLlocal1 (rv);
1179   virStoragePoolPtr pool = Pool_val (poolv);
1180   virConnectPtr conn = Connect_polv (poolv);
1181   char *r;
1182
1183   NONBLOCKING (r = virStorageVolGetPath (pool));
1184   CHECK_ERROR (!r, conn, "virStorageVolGetPath");
1185
1186   rv = caml_copy_string (r);
1187   free (r);
1188   CAMLreturn (rv);
1189 #endif
1190 }
1191
1192 #ifdef HAVE_WEAK_SYMBOLS
1193 #ifdef HAVE_VIRSTORAGEVOLGETKEY
1194 extern const char *virStorageVolGetKey (virStoragePoolPtr pool) __attribute__((weak));
1195 #endif
1196 #endif
1197
1198 CAMLprim value
1199 ocaml_libvirt_storage_vol_get_key (value poolv)
1200 {
1201   CAMLparam1 (poolv);
1202 #ifndef HAVE_VIRSTORAGEVOLGETKEY
1203   /* Symbol virStorageVolGetKey not found at compile time. */
1204   not_supported ("virStorageVolGetKey");
1205   /* Suppresses a compiler warning. */
1206   (void) caml__frame;
1207 #else
1208   /* Check that the symbol virStorageVolGetKey
1209    * is in runtime version of libvirt.
1210    */
1211   WEAK_SYMBOL_CHECK (virStorageVolGetKey);
1212
1213   CAMLlocal1 (rv);
1214   virStoragePoolPtr pool = Pool_val (poolv);
1215   virConnectPtr conn = Connect_polv (poolv);
1216   const char *r;
1217
1218   NONBLOCKING (r = virStorageVolGetKey (pool));
1219   CHECK_ERROR (!r, conn, "virStorageVolGetKey");
1220
1221   rv = caml_copy_string (r);
1222   CAMLreturn (rv);
1223 #endif
1224 }
1225
1226 #ifdef HAVE_WEAK_SYMBOLS
1227 #ifdef HAVE_VIRSTORAGEVOLGETNAME
1228 extern const char *virStorageVolGetName (virStoragePoolPtr pool) __attribute__((weak));
1229 #endif
1230 #endif
1231
1232 CAMLprim value
1233 ocaml_libvirt_storage_vol_get_name (value poolv)
1234 {
1235   CAMLparam1 (poolv);
1236 #ifndef HAVE_VIRSTORAGEVOLGETNAME
1237   /* Symbol virStorageVolGetName not found at compile time. */
1238   not_supported ("virStorageVolGetName");
1239   /* Suppresses a compiler warning. */
1240   (void) caml__frame;
1241 #else
1242   /* Check that the symbol virStorageVolGetName
1243    * is in runtime version of libvirt.
1244    */
1245   WEAK_SYMBOL_CHECK (virStorageVolGetName);
1246
1247   CAMLlocal1 (rv);
1248   virStoragePoolPtr pool = Pool_val (poolv);
1249   virConnectPtr conn = Connect_polv (poolv);
1250   const char *r;
1251
1252   NONBLOCKING (r = virStorageVolGetName (pool));
1253   CHECK_ERROR (!r, conn, "virStorageVolGetName");
1254
1255   rv = caml_copy_string (r);
1256   CAMLreturn (rv);
1257 #endif
1258 }
1259
1260 CAMLprim value
1261 ocaml_libvirt_domain_create_job ()
1262 {
1263   failwith ("ocaml_libvirt_domain_create_job is unimplemented");
1264 }
1265
1266 CAMLprim value
1267 ocaml_libvirt_domain_core_dump_job ()
1268 {
1269   failwith ("ocaml_libvirt_domain_core_dump_job is unimplemented");
1270 }
1271
1272 CAMLprim value
1273 ocaml_libvirt_domain_restore_job ()
1274 {
1275   failwith ("ocaml_libvirt_domain_restore_job is unimplemented");
1276 }
1277
1278 CAMLprim value
1279 ocaml_libvirt_domain_save_job ()
1280 {
1281   failwith ("ocaml_libvirt_domain_save_job is unimplemented");
1282 }
1283
1284 CAMLprim value
1285 ocaml_libvirt_connect_create_linux_job ()
1286 {
1287   failwith ("ocaml_libvirt_connect_create_linux_job is unimplemented");
1288 }
1289
1290 CAMLprim value
1291 ocaml_libvirt_network_create_job ()
1292 {
1293   failwith ("ocaml_libvirt_network_create_job is unimplemented");
1294 }
1295
1296 CAMLprim value
1297 ocaml_libvirt_network_create_xml_job ()
1298 {
1299   failwith ("ocaml_libvirt_network_create_xml_job is unimplemented");
1300 }
1301
1302 CAMLprim value
1303 ocaml_libvirt_storage_pool_set_autostart ()
1304 {
1305   failwith ("ocaml_libvirt_storage_pool_set_autostart is unimplemented");
1306 }
1307
1308 CAMLprim value
1309 ocaml_libvirt_storage_pool_get_autostart ()
1310 {
1311   failwith ("ocaml_libvirt_storage_pool_get_autostart is unimplemented");
1312 }
1313
1314 CAMLprim value
1315 ocaml_libvirt_storage_pool_get_info ()
1316 {
1317   failwith ("ocaml_libvirt_storage_pool_get_info is unimplemented");
1318 }
1319
1320 CAMLprim value
1321 ocaml_libvirt_storage_pool_get_uuid_string ()
1322 {
1323   failwith ("ocaml_libvirt_storage_pool_get_uuid_string is unimplemented");
1324 }
1325
1326 CAMLprim value
1327 ocaml_libvirt_storage_pool_get_uuid ()
1328 {
1329   failwith ("ocaml_libvirt_storage_pool_get_uuid is unimplemented");
1330 }
1331
1332 CAMLprim value
1333 ocaml_libvirt_storage_pool_free ()
1334 {
1335   failwith ("ocaml_libvirt_storage_pool_free is unimplemented");
1336 }
1337
1338 CAMLprim value
1339 ocaml_libvirt_storage_pool_destroy ()
1340 {
1341   failwith ("ocaml_libvirt_storage_pool_destroy is unimplemented");
1342 }
1343
1344 CAMLprim value
1345 ocaml_libvirt_storage_pool_define_xml ()
1346 {
1347   failwith ("ocaml_libvirt_storage_pool_define_xml is unimplemented");
1348 }
1349
1350 CAMLprim value
1351 ocaml_libvirt_storage_pool_create_xml ()
1352 {
1353   failwith ("ocaml_libvirt_storage_pool_create_xml is unimplemented");
1354 }
1355
1356 CAMLprim value
1357 ocaml_libvirt_storage_pool_lookup_by_uuid ()
1358 {
1359   failwith ("ocaml_libvirt_storage_pool_lookup_by_uuid is unimplemented");
1360 }
1361
1362 CAMLprim value
1363 ocaml_libvirt_storage_vol_free ()
1364 {
1365   failwith ("ocaml_libvirt_storage_vol_free is unimplemented");
1366 }
1367
1368 CAMLprim value
1369 ocaml_libvirt_storage_vol_destroy ()
1370 {
1371   failwith ("ocaml_libvirt_storage_vol_destroy is unimplemented");
1372 }
1373
1374 CAMLprim value
1375 ocaml_libvirt_storage_vol_create_xml ()
1376 {
1377   failwith ("ocaml_libvirt_storage_vol_create_xml is unimplemented");
1378 }
1379
1380 CAMLprim value
1381 ocaml_libvirt_storage_vol_get_info ()
1382 {
1383   failwith ("ocaml_libvirt_storage_vol_get_info is unimplemented");
1384 }
1385
1386 CAMLprim value
1387 ocaml_libvirt_pool_of_volume ()
1388 {
1389   failwith ("ocaml_libvirt_pool_of_volume is unimplemented");
1390 }
1391
1392 CAMLprim value
1393 ocaml_libvirt_job_cancel ()
1394 {
1395   failwith ("ocaml_libvirt_job_cancel is unimplemented");
1396 }
1397
1398 CAMLprim value
1399 ocaml_libvirt_job_get_network ()
1400 {
1401   failwith ("ocaml_libvirt_job_get_network is unimplemented");
1402 }
1403
1404 CAMLprim value
1405 ocaml_libvirt_job_get_domain ()
1406 {
1407   failwith ("ocaml_libvirt_job_get_domain is unimplemented");
1408 }
1409
1410 CAMLprim value
1411 ocaml_libvirt_job_get_info ()
1412 {
1413   failwith ("ocaml_libvirt_job_get_info is unimplemented");
1414 }
1415
1416 #include "libvirt_c_epilogue.c"
1417
1418 /* EOF */