libvirt/libvirt_c.c

   1 /* !!! WARNING WARNING WARNING WARNING WARNING WARNING WARNING !!!
   2  *
   3  * THIS FILE IS AUTOMATICALLY GENERATED BY 'generator.pl'.
   4  *
   5  * Any changes you make to this file may be overwritten.
   6  */
   7
   8 /* OCaml bindings for libvirt.
   9  * (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc.
  10  * http://libvirt.org/
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version,
  16  * with the OCaml linking exception described in ../COPYING.LIB.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  26  */
  27
  28 #include "config.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #include <libvirt/libvirt.h>
  35 #include <libvirt/virterror.h>
  36
  37 #include <caml/config.h>
  38 #include <caml/alloc.h>
  39 #include <caml/callback.h>
  40 #include <caml/custom.h>
  41 #include <caml/fail.h>
  42 #include <caml/memory.h>
  43 #include <caml/misc.h>
  44 #include <caml/mlvalues.h>
  45 #include <caml/signals.h>
  46
  47 #include "libvirt_c_prologue.c"
  48
  49 #include "libvirt_c_oneoffs.c"
  50
  51 /* Automatically generated binding for virConnectClose.
  52  * In generator.pl this function has signature "conn : free".
  53  */
  54
  55 CAMLprim value
  56 ocaml_libvirt_connect_close (value connv)
  57 {
  58   CAMLparam1 (connv);
  59
  60   virConnectPtr conn = Connect_val (connv);
  61   int r;
  62
  63   NONBLOCKING (r = virConnectClose (conn));
  64   CHECK_ERROR (r == -1, conn, "virConnectClose");
  65
  66   /* So that we don't double-free in the finalizer: */
  67   Connect_val (connv) = NULL;
  68
  69   CAMLreturn (Val_unit);
  70 }
  71
  72 /* Automatically generated binding for virConnectGetHostname.
  73  * In generator.pl this function has signature "conn : string".
  74  */
  75
  76 CAMLprim value
  77 ocaml_libvirt_connect_get_hostname (value connv)
  78 {
  79   CAMLparam1 (connv);
  80
  81   CAMLlocal1 (rv);
  82   virConnectPtr conn = Connect_val (connv);
  83   char *r;
  84
  85   NONBLOCKING (r = virConnectGetHostname (conn));
  86   CHECK_ERROR (!r, conn, "virConnectGetHostname");
  87
  88   rv = caml_copy_string (r);
  89   free (r);
  90   CAMLreturn (rv);
  91 }
  92
  93 /* Automatically generated binding for virConnectGetURI.
  94  * In generator.pl this function has signature "conn : string".
  95  */
  96
  97 CAMLprim value
  98 ocaml_libvirt_connect_get_uri (value connv)
  99 {
 100   CAMLparam1 (connv);
 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 }
 113
 114 /* Automatically generated binding for virConnectGetType.
 115  * In generator.pl this function has signature "conn : static string".
 116  */
 117
 118 CAMLprim value
 119 ocaml_libvirt_connect_get_type (value connv)
 120 {
 121   CAMLparam1 (connv);
 122
 123   CAMLlocal1 (rv);
 124   virConnectPtr conn = Connect_val (connv);
 125   const char *r;
 126
 127   NONBLOCKING (r = virConnectGetType (conn));
 128   CHECK_ERROR (!r, conn, "virConnectGetType");
 129
 130   rv = caml_copy_string (r);
 131   CAMLreturn (rv);
 132 }
 133
 134 /* Automatically generated binding for virConnectNumOfDomains.
 135  * In generator.pl this function has signature "conn : int".
 136  */
 137
 138 CAMLprim value
 139 ocaml_libvirt_connect_num_of_domains (value connv)
 140 {
 141   CAMLparam1 (connv);
 142
 143   virConnectPtr conn = Connect_val (connv);
 144   int r;
 145
 146   NONBLOCKING (r = virConnectNumOfDomains (conn));
 147   CHECK_ERROR (r == -1, conn, "virConnectNumOfDomains");
 148
 149   CAMLreturn (Val_int (r));
 150 }
 151
 152 /* Automatically generated binding for virConnectListDomains.
 153  * In generator.pl this function has signature "conn, int : int array".
 154  */
 155
 156 CAMLprim value
 157 ocaml_libvirt_connect_list_domains (value connv, value iv)
 158 {
 159   CAMLparam2 (connv, iv);
 160
 161   CAMLlocal1 (rv);
 162   virConnectPtr conn = Connect_val (connv);
 163   int i = Int_val (iv);
 164   int ids[i], r;
 165
 166   /* Some libvirt List* functions still throw exceptions if i == 0,
 167    * so catch that and return an empty array directly.  This changes
 168    * the semantics slightly (masking other failures) but it's
 169    * unlikely anyone will care.  RWMJ 2008/06/10
 170    */
 171   if (i == 0) {
 172     rv = caml_alloc (0, 0);
 173     CAMLreturn (rv);
 174   }
 175
 176   NONBLOCKING (r = virConnectListDomains (conn, ids, i));
 177   CHECK_ERROR (r == -1, conn, "virConnectListDomains");
 178
 179   rv = caml_alloc (r, 0);
 180   for (i = 0; i < r; ++i)
 181     Store_field (rv, i, Val_int (ids[i]));
 182
 183   CAMLreturn (rv);
 184 }
 185
 186 /* Automatically generated binding for virConnectNumOfDefinedDomains.
 187  * In generator.pl this function has signature "conn : int".
 188  */
 189
 190 CAMLprim value
 191 ocaml_libvirt_connect_num_of_defined_domains (value connv)
 192 {
 193   CAMLparam1 (connv);
 194
 195   virConnectPtr conn = Connect_val (connv);
 196   int r;
 197
 198   NONBLOCKING (r = virConnectNumOfDefinedDomains (conn));
 199   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedDomains");
 200
 201   CAMLreturn (Val_int (r));
 202 }
 203
 204 /* Automatically generated binding for virConnectListDefinedDomains.
 205  * In generator.pl this function has signature "conn, int : string array".
 206  */
 207
 208 CAMLprim value
 209 ocaml_libvirt_connect_list_defined_domains (value connv, value iv)
 210 {
 211   CAMLparam2 (connv, iv);
 212
 213   CAMLlocal2 (rv, strv);
 214   virConnectPtr conn = Connect_val (connv);
 215   int i = Int_val (iv);
 216   char *names[i];
 217   int r;
 218
 219   /* Some libvirt List* functions still throw exceptions if i == 0,
 220    * so catch that and return an empty array directly.  This changes
 221    * the semantics slightly (masking other failures) but it's
 222    * unlikely anyone will care.  RWMJ 2008/06/10
 223    */
 224   if (i == 0) {
 225     rv = caml_alloc (0, 0);
 226     CAMLreturn (rv);
 227   }
 228
 229   NONBLOCKING (r = virConnectListDefinedDomains (conn, names, i));
 230   CHECK_ERROR (r == -1, conn, "virConnectListDefinedDomains");
 231
 232   rv = caml_alloc (r, 0);
 233   for (i = 0; i < r; ++i) {
 234     strv = caml_copy_string (names[i]);
 235     Store_field (rv, i, strv);
 236     free (names[i]);
 237   }
 238
 239   CAMLreturn (rv);
 240 }
 241
 242 /* Automatically generated binding for virConnectNumOfNetworks.
 243  * In generator.pl this function has signature "conn : int".
 244  */
 245
 246 CAMLprim value
 247 ocaml_libvirt_connect_num_of_networks (value connv)
 248 {
 249   CAMLparam1 (connv);
 250
 251   virConnectPtr conn = Connect_val (connv);
 252   int r;
 253
 254   NONBLOCKING (r = virConnectNumOfNetworks (conn));
 255   CHECK_ERROR (r == -1, conn, "virConnectNumOfNetworks");
 256
 257   CAMLreturn (Val_int (r));
 258 }
 259
 260 /* Automatically generated binding for virConnectListNetworks.
 261  * In generator.pl this function has signature "conn, int : string array".
 262  */
 263
 264 CAMLprim value
 265 ocaml_libvirt_connect_list_networks (value connv, value iv)
 266 {
 267   CAMLparam2 (connv, iv);
 268
 269   CAMLlocal2 (rv, strv);
 270   virConnectPtr conn = Connect_val (connv);
 271   int i = Int_val (iv);
 272   char *names[i];
 273   int r;
 274
 275   /* Some libvirt List* functions still throw exceptions if i == 0,
 276    * so catch that and return an empty array directly.  This changes
 277    * the semantics slightly (masking other failures) but it's
 278    * unlikely anyone will care.  RWMJ 2008/06/10
 279    */
 280   if (i == 0) {
 281     rv = caml_alloc (0, 0);
 282     CAMLreturn (rv);
 283   }
 284
 285   NONBLOCKING (r = virConnectListNetworks (conn, names, i));
 286   CHECK_ERROR (r == -1, conn, "virConnectListNetworks");
 287
 288   rv = caml_alloc (r, 0);
 289   for (i = 0; i < r; ++i) {
 290     strv = caml_copy_string (names[i]);
 291     Store_field (rv, i, strv);
 292     free (names[i]);
 293   }
 294
 295   CAMLreturn (rv);
 296 }
 297
 298 /* Automatically generated binding for virConnectNumOfDefinedNetworks.
 299  * In generator.pl this function has signature "conn : int".
 300  */
 301
 302 CAMLprim value
 303 ocaml_libvirt_connect_num_of_defined_networks (value connv)
 304 {
 305   CAMLparam1 (connv);
 306
 307   virConnectPtr conn = Connect_val (connv);
 308   int r;
 309
 310   NONBLOCKING (r = virConnectNumOfDefinedNetworks (conn));
 311   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedNetworks");
 312
 313   CAMLreturn (Val_int (r));
 314 }
 315
 316 /* Automatically generated binding for virConnectListDefinedNetworks.
 317  * In generator.pl this function has signature "conn, int : string array".
 318  */
 319
 320 CAMLprim value
 321 ocaml_libvirt_connect_list_defined_networks (value connv, value iv)
 322 {
 323   CAMLparam2 (connv, iv);
 324
 325   CAMLlocal2 (rv, strv);
 326   virConnectPtr conn = Connect_val (connv);
 327   int i = Int_val (iv);
 328   char *names[i];
 329   int r;
 330
 331   /* Some libvirt List* functions still throw exceptions if i == 0,
 332    * so catch that and return an empty array directly.  This changes
 333    * the semantics slightly (masking other failures) but it's
 334    * unlikely anyone will care.  RWMJ 2008/06/10
 335    */
 336   if (i == 0) {
 337     rv = caml_alloc (0, 0);
 338     CAMLreturn (rv);
 339   }
 340
 341   NONBLOCKING (r = virConnectListDefinedNetworks (conn, names, i));
 342   CHECK_ERROR (r == -1, conn, "virConnectListDefinedNetworks");
 343
 344   rv = caml_alloc (r, 0);
 345   for (i = 0; i < r; ++i) {
 346     strv = caml_copy_string (names[i]);
 347     Store_field (rv, i, strv);
 348     free (names[i]);
 349   }
 350
 351   CAMLreturn (rv);
 352 }
 353
 354 /* Automatically generated binding for virConnectNumOfStoragePools.
 355  * In generator.pl this function has signature "conn : int".
 356  */
 357
 358 CAMLprim value
 359 ocaml_libvirt_connect_num_of_storage_pools (value connv)
 360 {
 361   CAMLparam1 (connv);
 362
 363   virConnectPtr conn = Connect_val (connv);
 364   int r;
 365
 366   NONBLOCKING (r = virConnectNumOfStoragePools (conn));
 367   CHECK_ERROR (r == -1, conn, "virConnectNumOfStoragePools");
 368
 369   CAMLreturn (Val_int (r));
 370 }
 371
 372 /* Automatically generated binding for virConnectListStoragePools.
 373  * In generator.pl this function has signature "conn, int : string array".
 374  */
 375
 376 CAMLprim value
 377 ocaml_libvirt_connect_list_storage_pools (value connv, value iv)
 378 {
 379   CAMLparam2 (connv, iv);
 380
 381   CAMLlocal2 (rv, strv);
 382   virConnectPtr conn = Connect_val (connv);
 383   int i = Int_val (iv);
 384   char *names[i];
 385   int r;
 386
 387   /* Some libvirt List* functions still throw exceptions if i == 0,
 388    * so catch that and return an empty array directly.  This changes
 389    * the semantics slightly (masking other failures) but it's
 390    * unlikely anyone will care.  RWMJ 2008/06/10
 391    */
 392   if (i == 0) {
 393     rv = caml_alloc (0, 0);
 394     CAMLreturn (rv);
 395   }
 396
 397   NONBLOCKING (r = virConnectListStoragePools (conn, names, i));
 398   CHECK_ERROR (r == -1, conn, "virConnectListStoragePools");
 399
 400   rv = caml_alloc (r, 0);
 401   for (i = 0; i < r; ++i) {
 402     strv = caml_copy_string (names[i]);
 403     Store_field (rv, i, strv);
 404     free (names[i]);
 405   }
 406
 407   CAMLreturn (rv);
 408 }
 409
 410 /* Automatically generated binding for virConnectNumOfDefinedStoragePools.
 411  * In generator.pl this function has signature "conn : int".
 412  */
 413
 414 CAMLprim value
 415 ocaml_libvirt_connect_num_of_defined_storage_pools (value connv)
 416 {
 417   CAMLparam1 (connv);
 418
 419   virConnectPtr conn = Connect_val (connv);
 420   int r;
 421
 422   NONBLOCKING (r = virConnectNumOfDefinedStoragePools (conn));
 423   CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedStoragePools");
 424
 425   CAMLreturn (Val_int (r));
 426 }
 427
 428 /* Automatically generated binding for virConnectListDefinedStoragePools.
 429  * In generator.pl this function has signature "conn, int : string array".
 430  */
 431
 432 CAMLprim value
 433 ocaml_libvirt_connect_list_defined_storage_pools (value connv, value iv)
 434 {
 435   CAMLparam2 (connv, iv);
 436
 437   CAMLlocal2 (rv, strv);
 438   virConnectPtr conn = Connect_val (connv);
 439   int i = Int_val (iv);
 440   char *names[i];
 441   int r;
 442
 443   /* Some libvirt List* functions still throw exceptions if i == 0,
 444    * so catch that and return an empty array directly.  This changes
 445    * the semantics slightly (masking other failures) but it's
 446    * unlikely anyone will care.  RWMJ 2008/06/10
 447    */
 448   if (i == 0) {
 449     rv = caml_alloc (0, 0);
 450     CAMLreturn (rv);
 451   }
 452
 453   NONBLOCKING (r = virConnectListDefinedStoragePools (conn, names, i));
 454   CHECK_ERROR (r == -1, conn, "virConnectListDefinedStoragePools");
 455
 456   rv = caml_alloc (r, 0);
 457   for (i = 0; i < r; ++i) {
 458     strv = caml_copy_string (names[i]);
 459     Store_field (rv, i, strv);
 460     free (names[i]);
 461   }
 462
 463   CAMLreturn (rv);
 464 }
 465
 466 /* Automatically generated binding for virConnectGetCapabilities.
 467  * In generator.pl this function has signature "conn : string".
 468  */
 469
 470 CAMLprim value
 471 ocaml_libvirt_connect_get_capabilities (value connv)
 472 {
 473   CAMLparam1 (connv);
 474
 475   CAMLlocal1 (rv);
 476   virConnectPtr conn = Connect_val (connv);
 477   char *r;
 478
 479   NONBLOCKING (r = virConnectGetCapabilities (conn));
 480   CHECK_ERROR (!r, conn, "virConnectGetCapabilities");
 481
 482   rv = caml_copy_string (r);
 483   free (r);
 484   CAMLreturn (rv);
 485 }
 486
 487 /* Automatically generated binding for virConnectDomainEventDeregisterAny.
 488  * In generator.pl this function has signature "conn, int : unit".
 489  */
 490
 491 CAMLprim value
 492 ocaml_libvirt_connect_domain_event_deregister_any (value connv, value iv)
 493 {
 494   CAMLparam2 (connv, iv);
 495
 496   virConnectPtr conn = Connect_val (connv);
 497   int i = Int_val (iv);
 498   int r;
 499
 500   NONBLOCKING (r = virConnectDomainEventDeregisterAny (conn, i));
 501   CHECK_ERROR (r == -1, conn, "virConnectDomainEventDeregisterAny");
 502
 503   CAMLreturn (Val_unit);
 504 }
 505
 506 /* Automatically generated binding for virDomainCreateLinux.
 507  * In generator.pl this function has signature "conn, string, 0U : dom".
 508  */
 509
 510 CAMLprim value
 511 ocaml_libvirt_domain_create_linux (value connv, value strv)
 512 {
 513   CAMLparam2 (connv, strv);
 514
 515   CAMLlocal1 (rv);
 516   virConnectPtr conn = Connect_val (connv);
 517   char *str = String_val (strv);
 518   virDomainPtr r;
 519
 520   NONBLOCKING (r = virDomainCreateLinux (conn, str, 0));
 521   CHECK_ERROR (!r, conn, "virDomainCreateLinux");
 522
 523   rv = Val_domain (r, connv);
 524
 525   CAMLreturn (rv);
 526 }
 527
 528 /* Automatically generated binding for virDomainCreateXML.
 529  * In generator.pl this function has signature "conn, string, unsigned : dom".
 530  */
 531
 532 CAMLprim value
 533 ocaml_libvirt_domain_create_xml (value connv, value strv, value uv)
 534 {
 535   CAMLparam3 (connv, strv, uv);
 536
 537   CAMLlocal1 (rv);
 538   virConnectPtr conn = Connect_val (connv);
 539   char *str = String_val (strv);
 540   unsigned int u = Int_val (uv);
 541   virDomainPtr r;
 542
 543   NONBLOCKING (r = virDomainCreateXML (conn, str, u));
 544   CHECK_ERROR (!r, conn, "virDomainCreateXML");
 545
 546   rv = Val_domain (r, connv);
 547
 548   CAMLreturn (rv);
 549 }
 550
 551 /* Automatically generated binding for virDomainFree.
 552  * In generator.pl this function has signature "dom : free".
 553  */
 554
 555 CAMLprim value
 556 ocaml_libvirt_domain_free (value domv)
 557 {
 558   CAMLparam1 (domv);
 559
 560   virDomainPtr dom = Domain_val (domv);
 561   virConnectPtr conn = Connect_domv (domv);
 562   int r;
 563
 564   NONBLOCKING (r = virDomainFree (dom));
 565   CHECK_ERROR (r == -1, conn, "virDomainFree");
 566
 567   /* So that we don't double-free in the finalizer: */
 568   Domain_val (domv) = NULL;
 569
 570   CAMLreturn (Val_unit);
 571 }
 572
 573 /* Automatically generated binding for virDomainDestroy.
 574  * In generator.pl this function has signature "dom : free".
 575  */
 576
 577 CAMLprim value
 578 ocaml_libvirt_domain_destroy (value domv)
 579 {
 580   CAMLparam1 (domv);
 581
 582   virDomainPtr dom = Domain_val (domv);
 583   virConnectPtr conn = Connect_domv (domv);
 584   int r;
 585
 586   NONBLOCKING (r = virDomainDestroy (dom));
 587   CHECK_ERROR (r == -1, conn, "virDomainDestroy");
 588
 589   /* So that we don't double-free in the finalizer: */
 590   Domain_val (domv) = NULL;
 591
 592   CAMLreturn (Val_unit);
 593 }
 594
 595 /* Automatically generated binding for virDomainLookupByName.
 596  * In generator.pl this function has signature "conn, string : dom".
 597  */
 598
 599 CAMLprim value
 600 ocaml_libvirt_domain_lookup_by_name (value connv, value strv)
 601 {
 602   CAMLparam2 (connv, strv);
 603
 604   CAMLlocal1 (rv);
 605   virConnectPtr conn = Connect_val (connv);
 606   char *str = String_val (strv);
 607   virDomainPtr r;
 608
 609   NONBLOCKING (r = virDomainLookupByName (conn, str));
 610   CHECK_ERROR (!r, conn, "virDomainLookupByName");
 611
 612   rv = Val_domain (r, connv);
 613
 614   CAMLreturn (rv);
 615 }
 616
 617 /* Automatically generated binding for virDomainLookupByID.
 618  * In generator.pl this function has signature "conn, int : dom".
 619  */
 620
 621 CAMLprim value
 622 ocaml_libvirt_domain_lookup_by_id (value connv, value iv)
 623 {
 624   CAMLparam2 (connv, iv);
 625
 626   CAMLlocal1 (rv);
 627   virConnectPtr conn = Connect_val (connv);
 628   int i = Int_val (iv);
 629   virDomainPtr r;
 630
 631   NONBLOCKING (r = virDomainLookupByID (conn, i));
 632   CHECK_ERROR (!r, conn, "virDomainLookupByID");
 633
 634   rv = Val_domain (r, connv);
 635
 636   CAMLreturn (rv);
 637 }
 638
 639 /* Automatically generated binding for virDomainLookupByUUID.
 640  * In generator.pl this function has signature "conn, uuid : dom".
 641  */
 642
 643 CAMLprim value
 644 ocaml_libvirt_domain_lookup_by_uuid (value connv, value uuidv)
 645 {
 646   CAMLparam2 (connv, uuidv);
 647
 648   CAMLlocal1 (rv);
 649   virConnectPtr conn = Connect_val (connv);
 650   unsigned char *uuid = (unsigned char *) String_val (uuidv);
 651   virDomainPtr r;
 652
 653   NONBLOCKING (r = virDomainLookupByUUID (conn, uuid));
 654   CHECK_ERROR (!r, conn, "virDomainLookupByUUID");
 655
 656   rv = Val_domain (r, connv);
 657
 658   CAMLreturn (rv);
 659 }
 660
 661 /* Automatically generated binding for virDomainLookupByUUIDString.
 662  * In generator.pl this function has signature "conn, string : dom".
 663  */
 664
 665 CAMLprim value
 666 ocaml_libvirt_domain_lookup_by_uuid_string (value connv, value strv)
 667 {
 668   CAMLparam2 (connv, strv);
 669
 670   CAMLlocal1 (rv);
 671   virConnectPtr conn = Connect_val (connv);
 672   char *str = String_val (strv);
 673   virDomainPtr r;
 674
 675   NONBLOCKING (r = virDomainLookupByUUIDString (conn, str));
 676   CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString");
 677
 678   rv = Val_domain (r, connv);
 679
 680   CAMLreturn (rv);
 681 }
 682
 683 /* Automatically generated binding for virDomainGetName.
 684  * In generator.pl this function has signature "dom : static string".
 685  */
 686
 687 CAMLprim value
 688 ocaml_libvirt_domain_get_name (value domv)
 689 {
 690   CAMLparam1 (domv);
 691
 692   CAMLlocal1 (rv);
 693   virDomainPtr dom = Domain_val (domv);
 694   virConnectPtr conn = Connect_domv (domv);
 695   const char *r;
 696
 697   NONBLOCKING (r = virDomainGetName (dom));
 698   CHECK_ERROR (!r, conn, "virDomainGetName");
 699
 700   rv = caml_copy_string (r);
 701   CAMLreturn (rv);
 702 }
 703
 704 /* Automatically generated binding for virDomainGetOSType.
 705  * In generator.pl this function has signature "dom : string".
 706  */
 707
 708 CAMLprim value
 709 ocaml_libvirt_domain_get_os_type (value domv)
 710 {
 711   CAMLparam1 (domv);
 712
 713   CAMLlocal1 (rv);
 714   virDomainPtr dom = Domain_val (domv);
 715   virConnectPtr conn = Connect_domv (domv);
 716   char *r;
 717
 718   NONBLOCKING (r = virDomainGetOSType (dom));
 719   CHECK_ERROR (!r, conn, "virDomainGetOSType");
 720
 721   rv = caml_copy_string (r);
 722   free (r);
 723   CAMLreturn (rv);
 724 }
 725
 726 /* Automatically generated binding for virDomainGetXMLDesc.
 727  * In generator.pl this function has signature "dom, 0 : string".
 728  */
 729
 730 CAMLprim value
 731 ocaml_libvirt_domain_get_xml_desc (value domv)
 732 {
 733   CAMLparam1 (domv);
 734
 735   CAMLlocal1 (rv);
 736   virDomainPtr dom = Domain_val (domv);
 737   virConnectPtr conn = Connect_domv (domv);
 738   char *r;
 739
 740   NONBLOCKING (r = virDomainGetXMLDesc (dom, 0));
 741   CHECK_ERROR (!r, conn, "virDomainGetXMLDesc");
 742
 743   rv = caml_copy_string (r);
 744   free (r);
 745   CAMLreturn (rv);
 746 }
 747
 748 /* Automatically generated binding for virDomainGetUUID.
 749  * In generator.pl this function has signature "dom : uuid".
 750  */
 751
 752 CAMLprim value
 753 ocaml_libvirt_domain_get_uuid (value domv)
 754 {
 755   CAMLparam1 (domv);
 756
 757   CAMLlocal1 (rv);
 758   virDomainPtr dom = Domain_val (domv);
 759   virConnectPtr conn = Connect_domv (domv);
 760   unsigned char uuid[VIR_UUID_BUFLEN];
 761   int r;
 762
 763   NONBLOCKING (r = virDomainGetUUID (dom, uuid));
 764   CHECK_ERROR (r == -1, conn, "virDomainGetUUID");
 765
 766   /* UUIDs are byte arrays with a fixed length. */
 767   rv = caml_alloc_string (VIR_UUID_BUFLEN);
 768   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
 769   CAMLreturn (rv);
 770 }
 771
 772 /* Automatically generated binding for virDomainGetUUIDString.
 773  * In generator.pl this function has signature "dom : uuid string".
 774  */
 775
 776 CAMLprim value
 777 ocaml_libvirt_domain_get_uuid_string (value domv)
 778 {
 779   CAMLparam1 (domv);
 780
 781   CAMLlocal1 (rv);
 782   virDomainPtr dom = Domain_val (domv);
 783   virConnectPtr conn = Connect_domv (domv);
 784   char uuid[VIR_UUID_STRING_BUFLEN];
 785   int r;
 786
 787   NONBLOCKING (r = virDomainGetUUIDString (dom, uuid));
 788   CHECK_ERROR (r == -1, conn, "virDomainGetUUIDString");
 789
 790   rv = caml_copy_string (uuid);
 791   CAMLreturn (rv);
 792 }
 793
 794 /* Automatically generated binding for virDomainGetMaxVcpus.
 795  * In generator.pl this function has signature "dom : int".
 796  */
 797
 798 CAMLprim value
 799 ocaml_libvirt_domain_get_max_vcpus (value domv)
 800 {
 801   CAMLparam1 (domv);
 802
 803   virDomainPtr dom = Domain_val (domv);
 804   virConnectPtr conn = Connect_domv (domv);
 805   int r;
 806
 807   NONBLOCKING (r = virDomainGetMaxVcpus (dom));
 808   CHECK_ERROR (r == -1, conn, "virDomainGetMaxVcpus");
 809
 810   CAMLreturn (Val_int (r));
 811 }
 812
 813 /* Automatically generated binding for virDomainSave.
 814  * In generator.pl this function has signature "dom, string : unit".
 815  */
 816
 817 CAMLprim value
 818 ocaml_libvirt_domain_save (value domv, value strv)
 819 {
 820   CAMLparam2 (domv, strv);
 821
 822   virDomainPtr dom = Domain_val (domv);
 823   virConnectPtr conn = Connect_domv (domv);
 824   char *str = String_val (strv);
 825   int r;
 826
 827   NONBLOCKING (r = virDomainSave (dom, str));
 828   CHECK_ERROR (r == -1, conn, "virDomainSave");
 829
 830   CAMLreturn (Val_unit);
 831 }
 832
 833 /* Automatically generated binding for virDomainRestore.
 834  * In generator.pl this function has signature "conn, string : unit".
 835  */
 836
 837 CAMLprim value
 838 ocaml_libvirt_domain_restore (value connv, value strv)
 839 {
 840   CAMLparam2 (connv, strv);
 841
 842   virConnectPtr conn = Connect_val (connv);
 843   char *str = String_val (strv);
 844   int r;
 845
 846   NONBLOCKING (r = virDomainRestore (conn, str));
 847   CHECK_ERROR (r == -1, conn, "virDomainRestore");
 848
 849   CAMLreturn (Val_unit);
 850 }
 851
 852 /* Automatically generated binding for virDomainCoreDump.
 853  * In generator.pl this function has signature "dom, string, 0 : unit".
 854  */
 855
 856 CAMLprim value
 857 ocaml_libvirt_domain_core_dump (value domv, value strv)
 858 {
 859   CAMLparam2 (domv, strv);
 860
 861   CAMLlocal1 (rv);
 862   virDomainPtr dom = Domain_val (domv);
 863   virConnectPtr conn = Connect_domv (domv);
 864   char *str = String_val (strv);
 865   int r;
 866
 867   NONBLOCKING (r = virDomainCoreDump (dom, str, 0));
 868   CHECK_ERROR (!r, conn, "virDomainCoreDump");
 869
 870   CAMLreturn (Val_unit);
 871 }
 872
 873 /* Automatically generated binding for virDomainSuspend.
 874  * In generator.pl this function has signature "dom : unit".
 875  */
 876
 877 CAMLprim value
 878 ocaml_libvirt_domain_suspend (value domv)
 879 {
 880   CAMLparam1 (domv);
 881
 882   virDomainPtr dom = Domain_val (domv);
 883   virConnectPtr conn = Connect_domv (domv);
 884   int r;
 885
 886   NONBLOCKING (r = virDomainSuspend (dom));
 887   CHECK_ERROR (r == -1, conn, "virDomainSuspend");
 888
 889   CAMLreturn (Val_unit);
 890 }
 891
 892 /* Automatically generated binding for virDomainResume.
 893  * In generator.pl this function has signature "dom : unit".
 894  */
 895
 896 CAMLprim value
 897 ocaml_libvirt_domain_resume (value domv)
 898 {
 899   CAMLparam1 (domv);
 900
 901   virDomainPtr dom = Domain_val (domv);
 902   virConnectPtr conn = Connect_domv (domv);
 903   int r;
 904
 905   NONBLOCKING (r = virDomainResume (dom));
 906   CHECK_ERROR (r == -1, conn, "virDomainResume");
 907
 908   CAMLreturn (Val_unit);
 909 }
 910
 911 /* Automatically generated binding for virDomainShutdown.
 912  * In generator.pl this function has signature "dom : unit".
 913  */
 914
 915 CAMLprim value
 916 ocaml_libvirt_domain_shutdown (value domv)
 917 {
 918   CAMLparam1 (domv);
 919
 920   virDomainPtr dom = Domain_val (domv);
 921   virConnectPtr conn = Connect_domv (domv);
 922   int r;
 923
 924   NONBLOCKING (r = virDomainShutdown (dom));
 925   CHECK_ERROR (r == -1, conn, "virDomainShutdown");
 926
 927   CAMLreturn (Val_unit);
 928 }
 929
 930 /* Automatically generated binding for virDomainReboot.
 931  * In generator.pl this function has signature "dom, 0 : unit".
 932  */
 933
 934 CAMLprim value
 935 ocaml_libvirt_domain_reboot (value domv)
 936 {
 937   CAMLparam1 (domv);
 938
 939   virDomainPtr dom = Domain_val (domv);
 940   virConnectPtr conn = Connect_domv (domv);
 941   int r;
 942
 943   NONBLOCKING (r = virDomainReboot (dom, 0));
 944   CHECK_ERROR (r == -1, conn, "virDomainReboot");
 945
 946   CAMLreturn (Val_unit);
 947 }
 948
 949 /* Automatically generated binding for virDomainDefineXML.
 950  * In generator.pl this function has signature "conn, string : dom".
 951  */
 952
 953 CAMLprim value
 954 ocaml_libvirt_domain_define_xml (value connv, value strv)
 955 {
 956   CAMLparam2 (connv, strv);
 957
 958   CAMLlocal1 (rv);
 959   virConnectPtr conn = Connect_val (connv);
 960   char *str = String_val (strv);
 961   virDomainPtr r;
 962
 963   NONBLOCKING (r = virDomainDefineXML (conn, str));
 964   CHECK_ERROR (!r, conn, "virDomainDefineXML");
 965
 966   rv = Val_domain (r, connv);
 967
 968   CAMLreturn (rv);
 969 }
 970
 971 /* Automatically generated binding for virDomainUndefine.
 972  * In generator.pl this function has signature "dom : unit".
 973  */
 974
 975 CAMLprim value
 976 ocaml_libvirt_domain_undefine (value domv)
 977 {
 978   CAMLparam1 (domv);
 979
 980   virDomainPtr dom = Domain_val (domv);
 981   virConnectPtr conn = Connect_domv (domv);
 982   int r;
 983
 984   NONBLOCKING (r = virDomainUndefine (dom));
 985   CHECK_ERROR (r == -1, conn, "virDomainUndefine");
 986
 987   CAMLreturn (Val_unit);
 988 }
 989
 990 /* Automatically generated binding for virDomainCreate.
 991  * In generator.pl this function has signature "dom : unit".
 992  */
 993
 994 CAMLprim value
 995 ocaml_libvirt_domain_create (value domv)
 996 {
 997   CAMLparam1 (domv);
 998
 999   virDomainPtr dom = Domain_val (domv);
1000   virConnectPtr conn = Connect_domv (domv);
1001   int r;
1002
1003   NONBLOCKING (r = virDomainCreate (dom));
1004   CHECK_ERROR (r == -1, conn, "virDomainCreate");
1005
1006   CAMLreturn (Val_unit);
1007 }
1008
1009 /* Automatically generated binding for virDomainAttachDevice.
1010  * In generator.pl this function has signature "dom, string : unit".
1011  */
1012
1013 CAMLprim value
1014 ocaml_libvirt_domain_attach_device (value domv, value strv)
1015 {
1016   CAMLparam2 (domv, strv);
1017
1018   virDomainPtr dom = Domain_val (domv);
1019   virConnectPtr conn = Connect_domv (domv);
1020   char *str = String_val (strv);
1021   int r;
1022
1023   NONBLOCKING (r = virDomainAttachDevice (dom, str));
1024   CHECK_ERROR (r == -1, conn, "virDomainAttachDevice");
1025
1026   CAMLreturn (Val_unit);
1027 }
1028
1029 /* Automatically generated binding for virDomainDetachDevice.
1030  * In generator.pl this function has signature "dom, string : unit".
1031  */
1032
1033 CAMLprim value
1034 ocaml_libvirt_domain_detach_device (value domv, value strv)
1035 {
1036   CAMLparam2 (domv, strv);
1037
1038   virDomainPtr dom = Domain_val (domv);
1039   virConnectPtr conn = Connect_domv (domv);
1040   char *str = String_val (strv);
1041   int r;
1042
1043   NONBLOCKING (r = virDomainDetachDevice (dom, str));
1044   CHECK_ERROR (r == -1, conn, "virDomainDetachDevice");
1045
1046   CAMLreturn (Val_unit);
1047 }
1048
1049 /* Automatically generated binding for virDomainGetAutostart.
1050  * In generator.pl this function has signature "dom : bool".
1051  */
1052
1053 CAMLprim value
1054 ocaml_libvirt_domain_get_autostart (value domv)
1055 {
1056   CAMLparam1 (domv);
1057
1058   virDomainPtr dom = Domain_val (domv);
1059   virConnectPtr conn = Connect_domv (domv);
1060   int r, b;
1061
1062   NONBLOCKING (r = virDomainGetAutostart (dom, &b));
1063   CHECK_ERROR (r == -1, conn, "virDomainGetAutostart");
1064
1065   CAMLreturn (b ? Val_true : Val_false);
1066 }
1067
1068 /* Automatically generated binding for virDomainSetAutostart.
1069  * In generator.pl this function has signature "dom, bool : unit".
1070  */
1071
1072 CAMLprim value
1073 ocaml_libvirt_domain_set_autostart (value domv, value bv)
1074 {
1075   CAMLparam2 (domv, bv);
1076
1077   virDomainPtr dom = Domain_val (domv);
1078   virConnectPtr conn = Connect_domv (domv);
1079   int r, b;
1080
1081   b = bv == Val_true ? 1 : 0;
1082
1083   NONBLOCKING (r = virDomainSetAutostart (dom, b));
1084   CHECK_ERROR (r == -1, conn, "virDomainSetAutostart");
1085
1086   CAMLreturn (Val_unit);
1087 }
1088
1089 /* Automatically generated binding for virNetworkFree.
1090  * In generator.pl this function has signature "net : free".
1091  */
1092
1093 CAMLprim value
1094 ocaml_libvirt_network_free (value netv)
1095 {
1096   CAMLparam1 (netv);
1097
1098   virNetworkPtr net = Network_val (netv);
1099   virConnectPtr conn = Connect_netv (netv);
1100   int r;
1101
1102   NONBLOCKING (r = virNetworkFree (net));
1103   CHECK_ERROR (r == -1, conn, "virNetworkFree");
1104
1105   /* So that we don't double-free in the finalizer: */
1106   Network_val (netv) = NULL;
1107
1108   CAMLreturn (Val_unit);
1109 }
1110
1111 /* Automatically generated binding for virNetworkDestroy.
1112  * In generator.pl this function has signature "net : free".
1113  */
1114
1115 CAMLprim value
1116 ocaml_libvirt_network_destroy (value netv)
1117 {
1118   CAMLparam1 (netv);
1119
1120   virNetworkPtr net = Network_val (netv);
1121   virConnectPtr conn = Connect_netv (netv);
1122   int r;
1123
1124   NONBLOCKING (r = virNetworkDestroy (net));
1125   CHECK_ERROR (r == -1, conn, "virNetworkDestroy");
1126
1127   /* So that we don't double-free in the finalizer: */
1128   Network_val (netv) = NULL;
1129
1130   CAMLreturn (Val_unit);
1131 }
1132
1133 /* Automatically generated binding for virNetworkLookupByName.
1134  * In generator.pl this function has signature "conn, string : net".
1135  */
1136
1137 CAMLprim value
1138 ocaml_libvirt_network_lookup_by_name (value connv, value strv)
1139 {
1140   CAMLparam2 (connv, strv);
1141
1142   CAMLlocal1 (rv);
1143   virConnectPtr conn = Connect_val (connv);
1144   char *str = String_val (strv);
1145   virNetworkPtr r;
1146
1147   NONBLOCKING (r = virNetworkLookupByName (conn, str));
1148   CHECK_ERROR (!r, conn, "virNetworkLookupByName");
1149
1150   rv = Val_network (r, connv);
1151
1152   CAMLreturn (rv);
1153 }
1154
1155 /* Automatically generated binding for virNetworkLookupByUUID.
1156  * In generator.pl this function has signature "conn, uuid : net".
1157  */
1158
1159 CAMLprim value
1160 ocaml_libvirt_network_lookup_by_uuid (value connv, value uuidv)
1161 {
1162   CAMLparam2 (connv, uuidv);
1163
1164   CAMLlocal1 (rv);
1165   virConnectPtr conn = Connect_val (connv);
1166   unsigned char *uuid = (unsigned char *) String_val (uuidv);
1167   virNetworkPtr r;
1168
1169   NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid));
1170   CHECK_ERROR (!r, conn, "virNetworkLookupByUUID");
1171
1172   rv = Val_network (r, connv);
1173
1174   CAMLreturn (rv);
1175 }
1176
1177 /* Automatically generated binding for virNetworkLookupByUUIDString.
1178  * In generator.pl this function has signature "conn, string : net".
1179  */
1180
1181 CAMLprim value
1182 ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv)
1183 {
1184   CAMLparam2 (connv, strv);
1185
1186   CAMLlocal1 (rv);
1187   virConnectPtr conn = Connect_val (connv);
1188   char *str = String_val (strv);
1189   virNetworkPtr r;
1190
1191   NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str));
1192   CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString");
1193
1194   rv = Val_network (r, connv);
1195
1196   CAMLreturn (rv);
1197 }
1198
1199 /* Automatically generated binding for virNetworkGetName.
1200  * In generator.pl this function has signature "net : static string".
1201  */
1202
1203 CAMLprim value
1204 ocaml_libvirt_network_get_name (value netv)
1205 {
1206   CAMLparam1 (netv);
1207
1208   CAMLlocal1 (rv);
1209   virNetworkPtr net = Network_val (netv);
1210   virConnectPtr conn = Connect_netv (netv);
1211   const char *r;
1212
1213   NONBLOCKING (r = virNetworkGetName (net));
1214   CHECK_ERROR (!r, conn, "virNetworkGetName");
1215
1216   rv = caml_copy_string (r);
1217   CAMLreturn (rv);
1218 }
1219
1220 /* Automatically generated binding for virNetworkGetXMLDesc.
1221  * In generator.pl this function has signature "net, 0 : string".
1222  */
1223
1224 CAMLprim value
1225 ocaml_libvirt_network_get_xml_desc (value netv)
1226 {
1227   CAMLparam1 (netv);
1228
1229   CAMLlocal1 (rv);
1230   virNetworkPtr net = Network_val (netv);
1231   virConnectPtr conn = Connect_netv (netv);
1232   char *r;
1233
1234   NONBLOCKING (r = virNetworkGetXMLDesc (net, 0));
1235   CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc");
1236
1237   rv = caml_copy_string (r);
1238   free (r);
1239   CAMLreturn (rv);
1240 }
1241
1242 /* Automatically generated binding for virNetworkGetBridgeName.
1243  * In generator.pl this function has signature "net : string".
1244  */
1245
1246 CAMLprim value
1247 ocaml_libvirt_network_get_bridge_name (value netv)
1248 {
1249   CAMLparam1 (netv);
1250
1251   CAMLlocal1 (rv);
1252   virNetworkPtr net = Network_val (netv);
1253   virConnectPtr conn = Connect_netv (netv);
1254   char *r;
1255
1256   NONBLOCKING (r = virNetworkGetBridgeName (net));
1257   CHECK_ERROR (!r, conn, "virNetworkGetBridgeName");
1258
1259   rv = caml_copy_string (r);
1260   free (r);
1261   CAMLreturn (rv);
1262 }
1263
1264 /* Automatically generated binding for virNetworkGetUUID.
1265  * In generator.pl this function has signature "net : uuid".
1266  */
1267
1268 CAMLprim value
1269 ocaml_libvirt_network_get_uuid (value netv)
1270 {
1271   CAMLparam1 (netv);
1272
1273   CAMLlocal1 (rv);
1274   virNetworkPtr net = Network_val (netv);
1275   virConnectPtr conn = Connect_netv (netv);
1276   unsigned char uuid[VIR_UUID_BUFLEN];
1277   int r;
1278
1279   NONBLOCKING (r = virNetworkGetUUID (net, uuid));
1280   CHECK_ERROR (r == -1, conn, "virNetworkGetUUID");
1281
1282   /* UUIDs are byte arrays with a fixed length. */
1283   rv = caml_alloc_string (VIR_UUID_BUFLEN);
1284   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
1285   CAMLreturn (rv);
1286 }
1287
1288 /* Automatically generated binding for virNetworkGetUUIDString.
1289  * In generator.pl this function has signature "net : uuid string".
1290  */
1291
1292 CAMLprim value
1293 ocaml_libvirt_network_get_uuid_string (value netv)
1294 {
1295   CAMLparam1 (netv);
1296
1297   CAMLlocal1 (rv);
1298   virNetworkPtr net = Network_val (netv);
1299   virConnectPtr conn = Connect_netv (netv);
1300   char uuid[VIR_UUID_STRING_BUFLEN];
1301   int r;
1302
1303   NONBLOCKING (r = virNetworkGetUUIDString (net, uuid));
1304   CHECK_ERROR (r == -1, conn, "virNetworkGetUUIDString");
1305
1306   rv = caml_copy_string (uuid);
1307   CAMLreturn (rv);
1308 }
1309
1310 /* Automatically generated binding for virNetworkUndefine.
1311  * In generator.pl this function has signature "net : unit".
1312  */
1313
1314 CAMLprim value
1315 ocaml_libvirt_network_undefine (value netv)
1316 {
1317   CAMLparam1 (netv);
1318
1319   virNetworkPtr net = Network_val (netv);
1320   virConnectPtr conn = Connect_netv (netv);
1321   int r;
1322
1323   NONBLOCKING (r = virNetworkUndefine (net));
1324   CHECK_ERROR (r == -1, conn, "virNetworkUndefine");
1325
1326   CAMLreturn (Val_unit);
1327 }
1328
1329 /* Automatically generated binding for virNetworkCreateXML.
1330  * In generator.pl this function has signature "conn, string : net".
1331  */
1332
1333 CAMLprim value
1334 ocaml_libvirt_network_create_xml (value connv, value strv)
1335 {
1336   CAMLparam2 (connv, strv);
1337
1338   CAMLlocal1 (rv);
1339   virConnectPtr conn = Connect_val (connv);
1340   char *str = String_val (strv);
1341   virNetworkPtr r;
1342
1343   NONBLOCKING (r = virNetworkCreateXML (conn, str));
1344   CHECK_ERROR (!r, conn, "virNetworkCreateXML");
1345
1346   rv = Val_network (r, connv);
1347
1348   CAMLreturn (rv);
1349 }
1350
1351 /* Automatically generated binding for virNetworkDefineXML.
1352  * In generator.pl this function has signature "conn, string : net".
1353  */
1354
1355 CAMLprim value
1356 ocaml_libvirt_network_define_xml (value connv, value strv)
1357 {
1358   CAMLparam2 (connv, strv);
1359
1360   CAMLlocal1 (rv);
1361   virConnectPtr conn = Connect_val (connv);
1362   char *str = String_val (strv);
1363   virNetworkPtr r;
1364
1365   NONBLOCKING (r = virNetworkDefineXML (conn, str));
1366   CHECK_ERROR (!r, conn, "virNetworkDefineXML");
1367
1368   rv = Val_network (r, connv);
1369
1370   CAMLreturn (rv);
1371 }
1372
1373 /* Automatically generated binding for virNetworkCreate.
1374  * In generator.pl this function has signature "net : unit".
1375  */
1376
1377 CAMLprim value
1378 ocaml_libvirt_network_create (value netv)
1379 {
1380   CAMLparam1 (netv);
1381
1382   virNetworkPtr net = Network_val (netv);
1383   virConnectPtr conn = Connect_netv (netv);
1384   int r;
1385
1386   NONBLOCKING (r = virNetworkCreate (net));
1387   CHECK_ERROR (r == -1, conn, "virNetworkCreate");
1388
1389   CAMLreturn (Val_unit);
1390 }
1391
1392 /* Automatically generated binding for virNetworkGetAutostart.
1393  * In generator.pl this function has signature "net : bool".
1394  */
1395
1396 CAMLprim value
1397 ocaml_libvirt_network_get_autostart (value netv)
1398 {
1399   CAMLparam1 (netv);
1400
1401   virNetworkPtr net = Network_val (netv);
1402   virConnectPtr conn = Connect_netv (netv);
1403   int r, b;
1404
1405   NONBLOCKING (r = virNetworkGetAutostart (net, &b));
1406   CHECK_ERROR (r == -1, conn, "virNetworkGetAutostart");
1407
1408   CAMLreturn (b ? Val_true : Val_false);
1409 }
1410
1411 /* Automatically generated binding for virNetworkSetAutostart.
1412  * In generator.pl this function has signature "net, bool : unit".
1413  */
1414
1415 CAMLprim value
1416 ocaml_libvirt_network_set_autostart (value netv, value bv)
1417 {
1418   CAMLparam2 (netv, bv);
1419
1420   virNetworkPtr net = Network_val (netv);
1421   virConnectPtr conn = Connect_netv (netv);
1422   int r, b;
1423
1424   b = bv == Val_true ? 1 : 0;
1425
1426   NONBLOCKING (r = virNetworkSetAutostart (net, b));
1427   CHECK_ERROR (r == -1, conn, "virNetworkSetAutostart");
1428
1429   CAMLreturn (Val_unit);
1430 }
1431
1432 /* Automatically generated binding for virStoragePoolFree.
1433  * In generator.pl this function has signature "pool : free".
1434  */
1435
1436 CAMLprim value
1437 ocaml_libvirt_storage_pool_free (value poolv)
1438 {
1439   CAMLparam1 (poolv);
1440
1441   virStoragePoolPtr pool = Pool_val (poolv);
1442   virConnectPtr conn = Connect_polv (poolv);
1443   int r;
1444
1445   NONBLOCKING (r = virStoragePoolFree (pool));
1446   CHECK_ERROR (r == -1, conn, "virStoragePoolFree");
1447
1448   /* So that we don't double-free in the finalizer: */
1449   Pool_val (poolv) = NULL;
1450
1451   CAMLreturn (Val_unit);
1452 }
1453
1454 /* Automatically generated binding for virStoragePoolDestroy.
1455  * In generator.pl this function has signature "pool : free".
1456  */
1457
1458 CAMLprim value
1459 ocaml_libvirt_storage_pool_destroy (value poolv)
1460 {
1461   CAMLparam1 (poolv);
1462
1463   virStoragePoolPtr pool = Pool_val (poolv);
1464   virConnectPtr conn = Connect_polv (poolv);
1465   int r;
1466
1467   NONBLOCKING (r = virStoragePoolDestroy (pool));
1468   CHECK_ERROR (r == -1, conn, "virStoragePoolDestroy");
1469
1470   /* So that we don't double-free in the finalizer: */
1471   Pool_val (poolv) = NULL;
1472
1473   CAMLreturn (Val_unit);
1474 }
1475
1476 /* Automatically generated binding for virStoragePoolLookupByName.
1477  * In generator.pl this function has signature "conn, string : pool".
1478  */
1479
1480 CAMLprim value
1481 ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv)
1482 {
1483   CAMLparam2 (connv, strv);
1484
1485   CAMLlocal1 (rv);
1486   virConnectPtr conn = Connect_val (connv);
1487   char *str = String_val (strv);
1488   virStoragePoolPtr r;
1489
1490   NONBLOCKING (r = virStoragePoolLookupByName (conn, str));
1491   CHECK_ERROR (!r, conn, "virStoragePoolLookupByName");
1492
1493   rv = Val_pool (r, connv);
1494
1495   CAMLreturn (rv);
1496 }
1497
1498 /* Automatically generated binding for virStoragePoolLookupByUUID.
1499  * In generator.pl this function has signature "conn, uuid : pool".
1500  */
1501
1502 CAMLprim value
1503 ocaml_libvirt_storage_pool_lookup_by_uuid (value connv, value uuidv)
1504 {
1505   CAMLparam2 (connv, uuidv);
1506
1507   CAMLlocal1 (rv);
1508   virConnectPtr conn = Connect_val (connv);
1509   unsigned char *uuid = (unsigned char *) String_val (uuidv);
1510   virStoragePoolPtr r;
1511
1512   NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid));
1513   CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID");
1514
1515   rv = Val_pool (r, connv);
1516
1517   CAMLreturn (rv);
1518 }
1519
1520 /* Automatically generated binding for virStoragePoolLookupByUUIDString.
1521  * In generator.pl this function has signature "conn, string : pool".
1522  */
1523
1524 CAMLprim value
1525 ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv)
1526 {
1527   CAMLparam2 (connv, strv);
1528
1529   CAMLlocal1 (rv);
1530   virConnectPtr conn = Connect_val (connv);
1531   char *str = String_val (strv);
1532   virStoragePoolPtr r;
1533
1534   NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str));
1535   CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString");
1536
1537   rv = Val_pool (r, connv);
1538
1539   CAMLreturn (rv);
1540 }
1541
1542 /* Automatically generated binding for virStoragePoolGetName.
1543  * In generator.pl this function has signature "pool : static string".
1544  */
1545
1546 CAMLprim value
1547 ocaml_libvirt_storage_pool_get_name (value poolv)
1548 {
1549   CAMLparam1 (poolv);
1550
1551   CAMLlocal1 (rv);
1552   virStoragePoolPtr pool = Pool_val (poolv);
1553   virConnectPtr conn = Connect_polv (poolv);
1554   const char *r;
1555
1556   NONBLOCKING (r = virStoragePoolGetName (pool));
1557   CHECK_ERROR (!r, conn, "virStoragePoolGetName");
1558
1559   rv = caml_copy_string (r);
1560   CAMLreturn (rv);
1561 }
1562
1563 /* Automatically generated binding for virStoragePoolGetXMLDesc.
1564  * In generator.pl this function has signature "pool, 0U : string".
1565  */
1566
1567 CAMLprim value
1568 ocaml_libvirt_storage_pool_get_xml_desc (value poolv)
1569 {
1570   CAMLparam1 (poolv);
1571
1572   CAMLlocal1 (rv);
1573   virStoragePoolPtr pool = Pool_val (poolv);
1574   virConnectPtr conn = Connect_polv (poolv);
1575   char *r;
1576
1577   NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0));
1578   CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc");
1579
1580   rv = caml_copy_string (r);
1581   free (r);
1582   CAMLreturn (rv);
1583 }
1584
1585 /* Automatically generated binding for virStoragePoolGetUUID.
1586  * In generator.pl this function has signature "pool : uuid".
1587  */
1588
1589 CAMLprim value
1590 ocaml_libvirt_storage_pool_get_uuid (value poolv)
1591 {
1592   CAMLparam1 (poolv);
1593
1594   CAMLlocal1 (rv);
1595   virStoragePoolPtr pool = Pool_val (poolv);
1596   virConnectPtr conn = Connect_polv (poolv);
1597   unsigned char uuid[VIR_UUID_BUFLEN];
1598   int r;
1599
1600   NONBLOCKING (r = virStoragePoolGetUUID (pool, uuid));
1601   CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUID");
1602
1603   /* UUIDs are byte arrays with a fixed length. */
1604   rv = caml_alloc_string (VIR_UUID_BUFLEN);
1605   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
1606   CAMLreturn (rv);
1607 }
1608
1609 /* Automatically generated binding for virStoragePoolGetUUIDString.
1610  * In generator.pl this function has signature "pool : uuid string".
1611  */
1612
1613 CAMLprim value
1614 ocaml_libvirt_storage_pool_get_uuid_string (value poolv)
1615 {
1616   CAMLparam1 (poolv);
1617
1618   CAMLlocal1 (rv);
1619   virStoragePoolPtr pool = Pool_val (poolv);
1620   virConnectPtr conn = Connect_polv (poolv);
1621   char uuid[VIR_UUID_STRING_BUFLEN];
1622   int r;
1623
1624   NONBLOCKING (r = virStoragePoolGetUUIDString (pool, uuid));
1625   CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUIDString");
1626
1627   rv = caml_copy_string (uuid);
1628   CAMLreturn (rv);
1629 }
1630
1631 /* Automatically generated binding for virStoragePoolCreateXML.
1632  * In generator.pl this function has signature "conn, string, 0U : pool".
1633  */
1634
1635 CAMLprim value
1636 ocaml_libvirt_storage_pool_create_xml (value connv, value strv)
1637 {
1638   CAMLparam2 (connv, strv);
1639
1640   CAMLlocal1 (rv);
1641   virConnectPtr conn = Connect_val (connv);
1642   char *str = String_val (strv);
1643   virStoragePoolPtr r;
1644
1645   NONBLOCKING (r = virStoragePoolCreateXML (conn, str, 0));
1646   CHECK_ERROR (!r, conn, "virStoragePoolCreateXML");
1647
1648   rv = Val_pool (r, connv);
1649
1650   CAMLreturn (rv);
1651 }
1652
1653 /* Automatically generated binding for virStoragePoolDefineXML.
1654  * In generator.pl this function has signature "conn, string, 0U : pool".
1655  */
1656
1657 CAMLprim value
1658 ocaml_libvirt_storage_pool_define_xml (value connv, value strv)
1659 {
1660   CAMLparam2 (connv, strv);
1661
1662   CAMLlocal1 (rv);
1663   virConnectPtr conn = Connect_val (connv);
1664   char *str = String_val (strv);
1665   virStoragePoolPtr r;
1666
1667   NONBLOCKING (r = virStoragePoolDefineXML (conn, str, 0));
1668   CHECK_ERROR (!r, conn, "virStoragePoolDefineXML");
1669
1670   rv = Val_pool (r, connv);
1671
1672   CAMLreturn (rv);
1673 }
1674
1675 /* Automatically generated binding for virStoragePoolBuild.
1676  * In generator.pl this function has signature "pool, uint : unit".
1677  */
1678
1679 CAMLprim value
1680 ocaml_libvirt_storage_pool_build (value poolv, value iv)
1681 {
1682   CAMLparam2 (poolv, iv);
1683
1684   virStoragePoolPtr pool = Pool_val (poolv);
1685   virConnectPtr conn = Connect_polv (poolv);
1686   unsigned int i = Int_val (iv);
1687   int r;
1688
1689   NONBLOCKING (r = virStoragePoolBuild (pool, i));
1690   CHECK_ERROR (r == -1, conn, "virStoragePoolBuild");
1691
1692   CAMLreturn (Val_unit);
1693 }
1694
1695 /* Automatically generated binding for virStoragePoolUndefine.
1696  * In generator.pl this function has signature "pool : unit".
1697  */
1698
1699 CAMLprim value
1700 ocaml_libvirt_storage_pool_undefine (value poolv)
1701 {
1702   CAMLparam1 (poolv);
1703
1704   virStoragePoolPtr pool = Pool_val (poolv);
1705   virConnectPtr conn = Connect_polv (poolv);
1706   int r;
1707
1708   NONBLOCKING (r = virStoragePoolUndefine (pool));
1709   CHECK_ERROR (r == -1, conn, "virStoragePoolUndefine");
1710
1711   CAMLreturn (Val_unit);
1712 }
1713
1714 /* Automatically generated binding for virStoragePoolCreate.
1715  * In generator.pl this function has signature "pool, 0U : unit".
1716  */
1717
1718 CAMLprim value
1719 ocaml_libvirt_storage_pool_create (value poolv)
1720 {
1721   CAMLparam1 (poolv);
1722
1723   virStoragePoolPtr pool = Pool_val (poolv);
1724   virConnectPtr conn = Connect_polv (poolv);
1725   int r;
1726
1727   NONBLOCKING (r = virStoragePoolCreate (pool, 0));
1728   CHECK_ERROR (r == -1, conn, "virStoragePoolCreate");
1729
1730   CAMLreturn (Val_unit);
1731 }
1732
1733 /* Automatically generated binding for virStoragePoolDelete.
1734  * In generator.pl this function has signature "pool, uint : unit".
1735  */
1736
1737 CAMLprim value
1738 ocaml_libvirt_storage_pool_delete (value poolv, value iv)
1739 {
1740   CAMLparam2 (poolv, iv);
1741
1742   virStoragePoolPtr pool = Pool_val (poolv);
1743   virConnectPtr conn = Connect_polv (poolv);
1744   unsigned int i = Int_val (iv);
1745   int r;
1746
1747   NONBLOCKING (r = virStoragePoolDelete (pool, i));
1748   CHECK_ERROR (r == -1, conn, "virStoragePoolDelete");
1749
1750   CAMLreturn (Val_unit);
1751 }
1752
1753 /* Automatically generated binding for virStoragePoolRefresh.
1754  * In generator.pl this function has signature "pool, 0U : unit".
1755  */
1756
1757 CAMLprim value
1758 ocaml_libvirt_storage_pool_refresh (value poolv)
1759 {
1760   CAMLparam1 (poolv);
1761
1762   virStoragePoolPtr pool = Pool_val (poolv);
1763   virConnectPtr conn = Connect_polv (poolv);
1764   int r;
1765
1766   NONBLOCKING (r = virStoragePoolRefresh (pool, 0));
1767   CHECK_ERROR (r == -1, conn, "virStoragePoolRefresh");
1768
1769   CAMLreturn (Val_unit);
1770 }
1771
1772 /* Automatically generated binding for virStoragePoolGetAutostart.
1773  * In generator.pl this function has signature "pool : bool".
1774  */
1775
1776 CAMLprim value
1777 ocaml_libvirt_storage_pool_get_autostart (value poolv)
1778 {
1779   CAMLparam1 (poolv);
1780
1781   virStoragePoolPtr pool = Pool_val (poolv);
1782   virConnectPtr conn = Connect_polv (poolv);
1783   int r, b;
1784
1785   NONBLOCKING (r = virStoragePoolGetAutostart (pool, &b));
1786   CHECK_ERROR (r == -1, conn, "virStoragePoolGetAutostart");
1787
1788   CAMLreturn (b ? Val_true : Val_false);
1789 }
1790
1791 /* Automatically generated binding for virStoragePoolSetAutostart.
1792  * In generator.pl this function has signature "pool, bool : unit".
1793  */
1794
1795 CAMLprim value
1796 ocaml_libvirt_storage_pool_set_autostart (value poolv, value bv)
1797 {
1798   CAMLparam2 (poolv, bv);
1799
1800   virStoragePoolPtr pool = Pool_val (poolv);
1801   virConnectPtr conn = Connect_polv (poolv);
1802   int r, b;
1803
1804   b = bv == Val_true ? 1 : 0;
1805
1806   NONBLOCKING (r = virStoragePoolSetAutostart (pool, b));
1807   CHECK_ERROR (r == -1, conn, "virStoragePoolSetAutostart");
1808
1809   CAMLreturn (Val_unit);
1810 }
1811
1812 /* Automatically generated binding for virStoragePoolNumOfVolumes.
1813  * In generator.pl this function has signature "pool : int".
1814  */
1815
1816 CAMLprim value
1817 ocaml_libvirt_storage_pool_num_of_volumes (value poolv)
1818 {
1819   CAMLparam1 (poolv);
1820
1821   virStoragePoolPtr pool = Pool_val (poolv);
1822   virConnectPtr conn = Connect_polv (poolv);
1823   int r;
1824
1825   NONBLOCKING (r = virStoragePoolNumOfVolumes (pool));
1826   CHECK_ERROR (r == -1, conn, "virStoragePoolNumOfVolumes");
1827
1828   CAMLreturn (Val_int (r));
1829 }
1830
1831 /* Automatically generated binding for virStoragePoolListVolumes.
1832  * In generator.pl this function has signature "pool, int : string array".
1833  */
1834
1835 CAMLprim value
1836 ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv)
1837 {
1838   CAMLparam2 (poolv, iv);
1839
1840   CAMLlocal2 (rv, strv);
1841   virStoragePoolPtr pool = Pool_val (poolv);
1842   virConnectPtr conn = Connect_polv (poolv);
1843   int i = Int_val (iv);
1844   char *names[i];
1845   int r;
1846
1847   /* Some libvirt List* functions still throw exceptions if i == 0,
1848    * so catch that and return an empty array directly.  This changes
1849    * the semantics slightly (masking other failures) but it's
1850    * unlikely anyone will care.  RWMJ 2008/06/10
1851    */
1852   if (i == 0) {
1853     rv = caml_alloc (0, 0);
1854     CAMLreturn (rv);
1855   }
1856
1857   NONBLOCKING (r = virStoragePoolListVolumes (pool, names, i));
1858   CHECK_ERROR (r == -1, conn, "virStoragePoolListVolumes");
1859
1860   rv = caml_alloc (r, 0);
1861   for (i = 0; i < r; ++i) {
1862     strv = caml_copy_string (names[i]);
1863     Store_field (rv, i, strv);
1864     free (names[i]);
1865   }
1866
1867   CAMLreturn (rv);
1868 }
1869
1870 /* Automatically generated binding for virStorageVolFree.
1871  * In generator.pl this function has signature "vol : free".
1872  */
1873
1874 CAMLprim value
1875 ocaml_libvirt_storage_vol_free (value volv)
1876 {
1877   CAMLparam1 (volv);
1878
1879   virStorageVolPtr vol = Volume_val (volv);
1880   virConnectPtr conn = Connect_volv (volv);
1881   int r;
1882
1883   NONBLOCKING (r = virStorageVolFree (vol));
1884   CHECK_ERROR (r == -1, conn, "virStorageVolFree");
1885
1886   /* So that we don't double-free in the finalizer: */
1887   Volume_val (volv) = NULL;
1888
1889   CAMLreturn (Val_unit);
1890 }
1891
1892 /* Automatically generated binding for virStorageVolDelete.
1893  * In generator.pl this function has signature "vol, uint : unit".
1894  */
1895
1896 CAMLprim value
1897 ocaml_libvirt_storage_vol_delete (value volv, value iv)
1898 {
1899   CAMLparam2 (volv, iv);
1900
1901   virStorageVolPtr vol = Volume_val (volv);
1902   virConnectPtr conn = Connect_volv (volv);
1903   unsigned int i = Int_val (iv);
1904   int r;
1905
1906   NONBLOCKING (r = virStorageVolDelete (vol, i));
1907   CHECK_ERROR (r == -1, conn, "virStorageVolDelete");
1908
1909   CAMLreturn (Val_unit);
1910 }
1911
1912 /* Automatically generated binding for virStorageVolLookupByName.
1913  * In generator.pl this function has signature "pool, string : vol from pool".
1914  */
1915
1916 CAMLprim value
1917 ocaml_libvirt_storage_vol_lookup_by_name (value poolv, value strv)
1918 {
1919   CAMLparam2 (poolv, strv);
1920
1921   CAMLlocal2 (rv, connv);
1922   virStoragePoolPtr pool = Pool_val (poolv);
1923   virConnectPtr conn = Connect_polv (poolv);
1924   char *str = String_val (strv);
1925   virStorageVolPtr r;
1926
1927   NONBLOCKING (r = virStorageVolLookupByName (pool, str));
1928   CHECK_ERROR (!r, conn, "virStorageVolLookupByName");
1929
1930   connv = Field (poolv, 1);
1931   rv = Val_volume (r, connv);
1932
1933   CAMLreturn (rv);
1934 }
1935
1936 /* Automatically generated binding for virStorageVolLookupByKey.
1937  * In generator.pl this function has signature "conn, string : vol".
1938  */
1939
1940 CAMLprim value
1941 ocaml_libvirt_storage_vol_lookup_by_key (value connv, value strv)
1942 {
1943   CAMLparam2 (connv, strv);
1944
1945   CAMLlocal1 (rv);
1946   virConnectPtr conn = Connect_val (connv);
1947   char *str = String_val (strv);
1948   virStorageVolPtr r;
1949
1950   NONBLOCKING (r = virStorageVolLookupByKey (conn, str));
1951   CHECK_ERROR (!r, conn, "virStorageVolLookupByKey");
1952
1953   rv = Val_volume (r, connv);
1954
1955   CAMLreturn (rv);
1956 }
1957
1958 /* Automatically generated binding for virStorageVolLookupByPath.
1959  * In generator.pl this function has signature "conn, string : vol".
1960  */
1961
1962 CAMLprim value
1963 ocaml_libvirt_storage_vol_lookup_by_path (value connv, value strv)
1964 {
1965   CAMLparam2 (connv, strv);
1966
1967   CAMLlocal1 (rv);
1968   virConnectPtr conn = Connect_val (connv);
1969   char *str = String_val (strv);
1970   virStorageVolPtr r;
1971
1972   NONBLOCKING (r = virStorageVolLookupByPath (conn, str));
1973   CHECK_ERROR (!r, conn, "virStorageVolLookupByPath");
1974
1975   rv = Val_volume (r, connv);
1976
1977   CAMLreturn (rv);
1978 }
1979
1980 /* Automatically generated binding for virStorageVolCreateXML.
1981  * In generator.pl this function has signature "pool, string, 0U : vol from pool".
1982  */
1983
1984 CAMLprim value
1985 ocaml_libvirt_storage_vol_create_xml (value poolv, value strv)
1986 {
1987   CAMLparam2 (poolv, strv);
1988
1989   CAMLlocal2 (rv, connv);
1990   virStoragePoolPtr pool = Pool_val (poolv);
1991   virConnectPtr conn = Connect_polv (poolv);
1992   char *str = String_val (strv);
1993   virStorageVolPtr r;
1994
1995   NONBLOCKING (r = virStorageVolCreateXML (pool, str, 0));
1996   CHECK_ERROR (!r, conn, "virStorageVolCreateXML");
1997
1998   connv = Field (poolv, 1);
1999   rv = Val_volume (r, connv);
2000
2001   CAMLreturn (rv);
2002 }
2003
2004 /* Automatically generated binding for virStorageVolGetXMLDesc.
2005  * In generator.pl this function has signature "vol, 0U : string".
2006  */
2007
2008 CAMLprim value
2009 ocaml_libvirt_storage_vol_get_xml_desc (value volv)
2010 {
2011   CAMLparam1 (volv);
2012
2013   CAMLlocal1 (rv);
2014   virStorageVolPtr vol = Volume_val (volv);
2015   virConnectPtr conn = Connect_volv (volv);
2016   char *r;
2017
2018   NONBLOCKING (r = virStorageVolGetXMLDesc (vol, 0));
2019   CHECK_ERROR (!r, conn, "virStorageVolGetXMLDesc");
2020
2021   rv = caml_copy_string (r);
2022   free (r);
2023   CAMLreturn (rv);
2024 }
2025
2026 /* Automatically generated binding for virStorageVolGetPath.
2027  * In generator.pl this function has signature "vol : string".
2028  */
2029
2030 CAMLprim value
2031 ocaml_libvirt_storage_vol_get_path (value volv)
2032 {
2033   CAMLparam1 (volv);
2034
2035   CAMLlocal1 (rv);
2036   virStorageVolPtr vol = Volume_val (volv);
2037   virConnectPtr conn = Connect_volv (volv);
2038   char *r;
2039
2040   NONBLOCKING (r = virStorageVolGetPath (vol));
2041   CHECK_ERROR (!r, conn, "virStorageVolGetPath");
2042
2043   rv = caml_copy_string (r);
2044   free (r);
2045   CAMLreturn (rv);
2046 }
2047
2048 /* Automatically generated binding for virStorageVolGetKey.
2049  * In generator.pl this function has signature "vol : static string".
2050  */
2051
2052 CAMLprim value
2053 ocaml_libvirt_storage_vol_get_key (value volv)
2054 {
2055   CAMLparam1 (volv);
2056
2057   CAMLlocal1 (rv);
2058   virStorageVolPtr vol = Volume_val (volv);
2059   virConnectPtr conn = Connect_volv (volv);
2060   const char *r;
2061
2062   NONBLOCKING (r = virStorageVolGetKey (vol));
2063   CHECK_ERROR (!r, conn, "virStorageVolGetKey");
2064
2065   rv = caml_copy_string (r);
2066   CAMLreturn (rv);
2067 }
2068
2069 /* Automatically generated binding for virStorageVolGetName.
2070  * In generator.pl this function has signature "vol : static string".
2071  */
2072
2073 CAMLprim value
2074 ocaml_libvirt_storage_vol_get_name (value volv)
2075 {
2076   CAMLparam1 (volv);
2077
2078   CAMLlocal1 (rv);
2079   virStorageVolPtr vol = Volume_val (volv);
2080   virConnectPtr conn = Connect_volv (volv);
2081   const char *r;
2082
2083   NONBLOCKING (r = virStorageVolGetName (vol));
2084   CHECK_ERROR (!r, conn, "virStorageVolGetName");
2085
2086   rv = caml_copy_string (r);
2087   CAMLreturn (rv);
2088 }
2089
2090 /* Automatically generated binding for virStoragePoolLookupByVolume.
2091  * In generator.pl this function has signature "vol : pool from vol".
2092  */
2093
2094 CAMLprim value
2095 ocaml_libvirt_storage_pool_lookup_by_volume (value volv)
2096 {
2097   CAMLparam1 (volv);
2098
2099   CAMLlocal2 (rv, connv);
2100   virStorageVolPtr vol = Volume_val (volv);
2101   virConnectPtr conn = Connect_volv (volv);
2102   virStoragePoolPtr r;
2103
2104   NONBLOCKING (r = virStoragePoolLookupByVolume (vol));
2105   CHECK_ERROR (!r, conn, "virStoragePoolLookupByVolume");
2106
2107   connv = Field (volv, 1);
2108   rv = Val_pool (r, connv);
2109
2110   CAMLreturn (rv);
2111 }
2112
2113 #include "libvirt_c_epilogue.c"
2114
2115 /* EOF */