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-2008 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 virDomainCreateLinux.
 488  * In generator.pl this function has signature "conn, string, 0U : dom".
 489  */
 490
 491 CAMLprim value
 492 ocaml_libvirt_domain_create_linux (value connv, value strv)
 493 {
 494   CAMLparam2 (connv, strv);
 495
 496   CAMLlocal1 (rv);
 497   virConnectPtr conn = Connect_val (connv);
 498   char *str = String_val (strv);
 499   virDomainPtr r;
 500
 501   NONBLOCKING (r = virDomainCreateLinux (conn, str, 0));
 502   CHECK_ERROR (!r, conn, "virDomainCreateLinux");
 503
 504   rv = Val_domain (r, connv);
 505
 506   CAMLreturn (rv);
 507 }
 508
 509 /* Automatically generated binding for virDomainFree.
 510  * In generator.pl this function has signature "dom : free".
 511  */
 512
 513 CAMLprim value
 514 ocaml_libvirt_domain_free (value domv)
 515 {
 516   CAMLparam1 (domv);
 517
 518   virDomainPtr dom = Domain_val (domv);
 519   virConnectPtr conn = Connect_domv (domv);
 520   int r;
 521
 522   NONBLOCKING (r = virDomainFree (dom));
 523   CHECK_ERROR (r == -1, conn, "virDomainFree");
 524
 525   /* So that we don't double-free in the finalizer: */
 526   Domain_val (domv) = NULL;
 527
 528   CAMLreturn (Val_unit);
 529 }
 530
 531 /* Automatically generated binding for virDomainDestroy.
 532  * In generator.pl this function has signature "dom : free".
 533  */
 534
 535 CAMLprim value
 536 ocaml_libvirt_domain_destroy (value domv)
 537 {
 538   CAMLparam1 (domv);
 539
 540   virDomainPtr dom = Domain_val (domv);
 541   virConnectPtr conn = Connect_domv (domv);
 542   int r;
 543
 544   NONBLOCKING (r = virDomainDestroy (dom));
 545   CHECK_ERROR (r == -1, conn, "virDomainDestroy");
 546
 547   /* So that we don't double-free in the finalizer: */
 548   Domain_val (domv) = NULL;
 549
 550   CAMLreturn (Val_unit);
 551 }
 552
 553 /* Automatically generated binding for virDomainLookupByName.
 554  * In generator.pl this function has signature "conn, string : dom".
 555  */
 556
 557 CAMLprim value
 558 ocaml_libvirt_domain_lookup_by_name (value connv, value strv)
 559 {
 560   CAMLparam2 (connv, strv);
 561
 562   CAMLlocal1 (rv);
 563   virConnectPtr conn = Connect_val (connv);
 564   char *str = String_val (strv);
 565   virDomainPtr r;
 566
 567   NONBLOCKING (r = virDomainLookupByName (conn, str));
 568   CHECK_ERROR (!r, conn, "virDomainLookupByName");
 569
 570   rv = Val_domain (r, connv);
 571
 572   CAMLreturn (rv);
 573 }
 574
 575 /* Automatically generated binding for virDomainLookupByID.
 576  * In generator.pl this function has signature "conn, int : dom".
 577  */
 578
 579 CAMLprim value
 580 ocaml_libvirt_domain_lookup_by_id (value connv, value iv)
 581 {
 582   CAMLparam2 (connv, iv);
 583
 584   CAMLlocal1 (rv);
 585   virConnectPtr conn = Connect_val (connv);
 586   int i = Int_val (iv);
 587   virDomainPtr r;
 588
 589   NONBLOCKING (r = virDomainLookupByID (conn, i));
 590   CHECK_ERROR (!r, conn, "virDomainLookupByID");
 591
 592   rv = Val_domain (r, connv);
 593
 594   CAMLreturn (rv);
 595 }
 596
 597 /* Automatically generated binding for virDomainLookupByUUID.
 598  * In generator.pl this function has signature "conn, uuid : dom".
 599  */
 600
 601 CAMLprim value
 602 ocaml_libvirt_domain_lookup_by_uuid (value connv, value uuidv)
 603 {
 604   CAMLparam2 (connv, uuidv);
 605
 606   CAMLlocal1 (rv);
 607   virConnectPtr conn = Connect_val (connv);
 608   unsigned char *uuid = (unsigned char *) String_val (uuidv);
 609   virDomainPtr r;
 610
 611   NONBLOCKING (r = virDomainLookupByUUID (conn, uuid));
 612   CHECK_ERROR (!r, conn, "virDomainLookupByUUID");
 613
 614   rv = Val_domain (r, connv);
 615
 616   CAMLreturn (rv);
 617 }
 618
 619 /* Automatically generated binding for virDomainLookupByUUIDString.
 620  * In generator.pl this function has signature "conn, string : dom".
 621  */
 622
 623 CAMLprim value
 624 ocaml_libvirt_domain_lookup_by_uuid_string (value connv, value strv)
 625 {
 626   CAMLparam2 (connv, strv);
 627
 628   CAMLlocal1 (rv);
 629   virConnectPtr conn = Connect_val (connv);
 630   char *str = String_val (strv);
 631   virDomainPtr r;
 632
 633   NONBLOCKING (r = virDomainLookupByUUIDString (conn, str));
 634   CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString");
 635
 636   rv = Val_domain (r, connv);
 637
 638   CAMLreturn (rv);
 639 }
 640
 641 /* Automatically generated binding for virDomainGetName.
 642  * In generator.pl this function has signature "dom : static string".
 643  */
 644
 645 CAMLprim value
 646 ocaml_libvirt_domain_get_name (value domv)
 647 {
 648   CAMLparam1 (domv);
 649
 650   CAMLlocal1 (rv);
 651   virDomainPtr dom = Domain_val (domv);
 652   virConnectPtr conn = Connect_domv (domv);
 653   const char *r;
 654
 655   NONBLOCKING (r = virDomainGetName (dom));
 656   CHECK_ERROR (!r, conn, "virDomainGetName");
 657
 658   rv = caml_copy_string (r);
 659   CAMLreturn (rv);
 660 }
 661
 662 /* Automatically generated binding for virDomainGetOSType.
 663  * In generator.pl this function has signature "dom : string".
 664  */
 665
 666 CAMLprim value
 667 ocaml_libvirt_domain_get_os_type (value domv)
 668 {
 669   CAMLparam1 (domv);
 670
 671   CAMLlocal1 (rv);
 672   virDomainPtr dom = Domain_val (domv);
 673   virConnectPtr conn = Connect_domv (domv);
 674   char *r;
 675
 676   NONBLOCKING (r = virDomainGetOSType (dom));
 677   CHECK_ERROR (!r, conn, "virDomainGetOSType");
 678
 679   rv = caml_copy_string (r);
 680   free (r);
 681   CAMLreturn (rv);
 682 }
 683
 684 /* Automatically generated binding for virDomainGetXMLDesc.
 685  * In generator.pl this function has signature "dom, 0 : string".
 686  */
 687
 688 CAMLprim value
 689 ocaml_libvirt_domain_get_xml_desc (value domv)
 690 {
 691   CAMLparam1 (domv);
 692
 693   CAMLlocal1 (rv);
 694   virDomainPtr dom = Domain_val (domv);
 695   virConnectPtr conn = Connect_domv (domv);
 696   char *r;
 697
 698   NONBLOCKING (r = virDomainGetXMLDesc (dom, 0));
 699   CHECK_ERROR (!r, conn, "virDomainGetXMLDesc");
 700
 701   rv = caml_copy_string (r);
 702   free (r);
 703   CAMLreturn (rv);
 704 }
 705
 706 /* Automatically generated binding for virDomainGetUUID.
 707  * In generator.pl this function has signature "dom : uuid".
 708  */
 709
 710 CAMLprim value
 711 ocaml_libvirt_domain_get_uuid (value domv)
 712 {
 713   CAMLparam1 (domv);
 714
 715   CAMLlocal1 (rv);
 716   virDomainPtr dom = Domain_val (domv);
 717   virConnectPtr conn = Connect_domv (domv);
 718   unsigned char uuid[VIR_UUID_BUFLEN];
 719   int r;
 720
 721   NONBLOCKING (r = virDomainGetUUID (dom, uuid));
 722   CHECK_ERROR (r == -1, conn, "virDomainGetUUID");
 723
 724   /* UUIDs are byte arrays with a fixed length. */
 725   rv = caml_alloc_string (VIR_UUID_BUFLEN);
 726   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
 727   CAMLreturn (rv);
 728 }
 729
 730 /* Automatically generated binding for virDomainGetUUIDString.
 731  * In generator.pl this function has signature "dom : uuid string".
 732  */
 733
 734 CAMLprim value
 735 ocaml_libvirt_domain_get_uuid_string (value domv)
 736 {
 737   CAMLparam1 (domv);
 738
 739   CAMLlocal1 (rv);
 740   virDomainPtr dom = Domain_val (domv);
 741   virConnectPtr conn = Connect_domv (domv);
 742   char uuid[VIR_UUID_STRING_BUFLEN];
 743   int r;
 744
 745   NONBLOCKING (r = virDomainGetUUIDString (dom, uuid));
 746   CHECK_ERROR (r == -1, conn, "virDomainGetUUIDString");
 747
 748   rv = caml_copy_string (uuid);
 749   CAMLreturn (rv);
 750 }
 751
 752 /* Automatically generated binding for virDomainGetMaxVcpus.
 753  * In generator.pl this function has signature "dom : int".
 754  */
 755
 756 CAMLprim value
 757 ocaml_libvirt_domain_get_max_vcpus (value domv)
 758 {
 759   CAMLparam1 (domv);
 760
 761   virDomainPtr dom = Domain_val (domv);
 762   virConnectPtr conn = Connect_domv (domv);
 763   int r;
 764
 765   NONBLOCKING (r = virDomainGetMaxVcpus (dom));
 766   CHECK_ERROR (r == -1, conn, "virDomainGetMaxVcpus");
 767
 768   CAMLreturn (Val_int (r));
 769 }
 770
 771 /* Automatically generated binding for virDomainSave.
 772  * In generator.pl this function has signature "dom, string : unit".
 773  */
 774
 775 CAMLprim value
 776 ocaml_libvirt_domain_save (value domv, value strv)
 777 {
 778   CAMLparam2 (domv, strv);
 779
 780   virDomainPtr dom = Domain_val (domv);
 781   virConnectPtr conn = Connect_domv (domv);
 782   char *str = String_val (strv);
 783   int r;
 784
 785   NONBLOCKING (r = virDomainSave (dom, str));
 786   CHECK_ERROR (r == -1, conn, "virDomainSave");
 787
 788   CAMLreturn (Val_unit);
 789 }
 790
 791 /* Automatically generated binding for virDomainRestore.
 792  * In generator.pl this function has signature "conn, string : unit".
 793  */
 794
 795 CAMLprim value
 796 ocaml_libvirt_domain_restore (value connv, value strv)
 797 {
 798   CAMLparam2 (connv, strv);
 799
 800   virConnectPtr conn = Connect_val (connv);
 801   char *str = String_val (strv);
 802   int r;
 803
 804   NONBLOCKING (r = virDomainRestore (conn, str));
 805   CHECK_ERROR (r == -1, conn, "virDomainRestore");
 806
 807   CAMLreturn (Val_unit);
 808 }
 809
 810 /* Automatically generated binding for virDomainCoreDump.
 811  * In generator.pl this function has signature "dom, string, 0 : unit".
 812  */
 813
 814 CAMLprim value
 815 ocaml_libvirt_domain_core_dump (value domv, value strv)
 816 {
 817   CAMLparam2 (domv, strv);
 818
 819   CAMLlocal1 (rv);
 820   virDomainPtr dom = Domain_val (domv);
 821   virConnectPtr conn = Connect_domv (domv);
 822   char *str = String_val (strv);
 823   int r;
 824
 825   NONBLOCKING (r = virDomainCoreDump (dom, str, 0));
 826   CHECK_ERROR (!r, conn, "virDomainCoreDump");
 827
 828   CAMLreturn (Val_unit);
 829 }
 830
 831 /* Automatically generated binding for virDomainSuspend.
 832  * In generator.pl this function has signature "dom : unit".
 833  */
 834
 835 CAMLprim value
 836 ocaml_libvirt_domain_suspend (value domv)
 837 {
 838   CAMLparam1 (domv);
 839
 840   virDomainPtr dom = Domain_val (domv);
 841   virConnectPtr conn = Connect_domv (domv);
 842   int r;
 843
 844   NONBLOCKING (r = virDomainSuspend (dom));
 845   CHECK_ERROR (r == -1, conn, "virDomainSuspend");
 846
 847   CAMLreturn (Val_unit);
 848 }
 849
 850 /* Automatically generated binding for virDomainResume.
 851  * In generator.pl this function has signature "dom : unit".
 852  */
 853
 854 CAMLprim value
 855 ocaml_libvirt_domain_resume (value domv)
 856 {
 857   CAMLparam1 (domv);
 858
 859   virDomainPtr dom = Domain_val (domv);
 860   virConnectPtr conn = Connect_domv (domv);
 861   int r;
 862
 863   NONBLOCKING (r = virDomainResume (dom));
 864   CHECK_ERROR (r == -1, conn, "virDomainResume");
 865
 866   CAMLreturn (Val_unit);
 867 }
 868
 869 /* Automatically generated binding for virDomainShutdown.
 870  * In generator.pl this function has signature "dom : unit".
 871  */
 872
 873 CAMLprim value
 874 ocaml_libvirt_domain_shutdown (value domv)
 875 {
 876   CAMLparam1 (domv);
 877
 878   virDomainPtr dom = Domain_val (domv);
 879   virConnectPtr conn = Connect_domv (domv);
 880   int r;
 881
 882   NONBLOCKING (r = virDomainShutdown (dom));
 883   CHECK_ERROR (r == -1, conn, "virDomainShutdown");
 884
 885   CAMLreturn (Val_unit);
 886 }
 887
 888 /* Automatically generated binding for virDomainReboot.
 889  * In generator.pl this function has signature "dom, 0 : unit".
 890  */
 891
 892 CAMLprim value
 893 ocaml_libvirt_domain_reboot (value domv)
 894 {
 895   CAMLparam1 (domv);
 896
 897   virDomainPtr dom = Domain_val (domv);
 898   virConnectPtr conn = Connect_domv (domv);
 899   int r;
 900
 901   NONBLOCKING (r = virDomainReboot (dom, 0));
 902   CHECK_ERROR (r == -1, conn, "virDomainReboot");
 903
 904   CAMLreturn (Val_unit);
 905 }
 906
 907 /* Automatically generated binding for virDomainDefineXML.
 908  * In generator.pl this function has signature "conn, string : dom".
 909  */
 910
 911 CAMLprim value
 912 ocaml_libvirt_domain_define_xml (value connv, value strv)
 913 {
 914   CAMLparam2 (connv, strv);
 915
 916   CAMLlocal1 (rv);
 917   virConnectPtr conn = Connect_val (connv);
 918   char *str = String_val (strv);
 919   virDomainPtr r;
 920
 921   NONBLOCKING (r = virDomainDefineXML (conn, str));
 922   CHECK_ERROR (!r, conn, "virDomainDefineXML");
 923
 924   rv = Val_domain (r, connv);
 925
 926   CAMLreturn (rv);
 927 }
 928
 929 /* Automatically generated binding for virDomainUndefine.
 930  * In generator.pl this function has signature "dom : unit".
 931  */
 932
 933 CAMLprim value
 934 ocaml_libvirt_domain_undefine (value domv)
 935 {
 936   CAMLparam1 (domv);
 937
 938   virDomainPtr dom = Domain_val (domv);
 939   virConnectPtr conn = Connect_domv (domv);
 940   int r;
 941
 942   NONBLOCKING (r = virDomainUndefine (dom));
 943   CHECK_ERROR (r == -1, conn, "virDomainUndefine");
 944
 945   CAMLreturn (Val_unit);
 946 }
 947
 948 /* Automatically generated binding for virDomainCreate.
 949  * In generator.pl this function has signature "dom : unit".
 950  */
 951
 952 CAMLprim value
 953 ocaml_libvirt_domain_create (value domv)
 954 {
 955   CAMLparam1 (domv);
 956
 957   virDomainPtr dom = Domain_val (domv);
 958   virConnectPtr conn = Connect_domv (domv);
 959   int r;
 960
 961   NONBLOCKING (r = virDomainCreate (dom));
 962   CHECK_ERROR (r == -1, conn, "virDomainCreate");
 963
 964   CAMLreturn (Val_unit);
 965 }
 966
 967 /* Automatically generated binding for virDomainAttachDevice.
 968  * In generator.pl this function has signature "dom, string : unit".
 969  */
 970
 971 CAMLprim value
 972 ocaml_libvirt_domain_attach_device (value domv, value strv)
 973 {
 974   CAMLparam2 (domv, strv);
 975
 976   virDomainPtr dom = Domain_val (domv);
 977   virConnectPtr conn = Connect_domv (domv);
 978   char *str = String_val (strv);
 979   int r;
 980
 981   NONBLOCKING (r = virDomainAttachDevice (dom, str));
 982   CHECK_ERROR (r == -1, conn, "virDomainAttachDevice");
 983
 984   CAMLreturn (Val_unit);
 985 }
 986
 987 /* Automatically generated binding for virDomainDetachDevice.
 988  * In generator.pl this function has signature "dom, string : unit".
 989  */
 990
 991 CAMLprim value
 992 ocaml_libvirt_domain_detach_device (value domv, value strv)
 993 {
 994   CAMLparam2 (domv, strv);
 995
 996   virDomainPtr dom = Domain_val (domv);
 997   virConnectPtr conn = Connect_domv (domv);
 998   char *str = String_val (strv);
 999   int r;
1000
1001   NONBLOCKING (r = virDomainDetachDevice (dom, str));
1002   CHECK_ERROR (r == -1, conn, "virDomainDetachDevice");
1003
1004   CAMLreturn (Val_unit);
1005 }
1006
1007 /* Automatically generated binding for virDomainGetAutostart.
1008  * In generator.pl this function has signature "dom : bool".
1009  */
1010
1011 CAMLprim value
1012 ocaml_libvirt_domain_get_autostart (value domv)
1013 {
1014   CAMLparam1 (domv);
1015
1016   virDomainPtr dom = Domain_val (domv);
1017   virConnectPtr conn = Connect_domv (domv);
1018   int r, b;
1019
1020   NONBLOCKING (r = virDomainGetAutostart (dom, &b));
1021   CHECK_ERROR (r == -1, conn, "virDomainGetAutostart");
1022
1023   CAMLreturn (b ? Val_true : Val_false);
1024 }
1025
1026 /* Automatically generated binding for virDomainSetAutostart.
1027  * In generator.pl this function has signature "dom, bool : unit".
1028  */
1029
1030 CAMLprim value
1031 ocaml_libvirt_domain_set_autostart (value domv, value bv)
1032 {
1033   CAMLparam2 (domv, bv);
1034
1035   virDomainPtr dom = Domain_val (domv);
1036   virConnectPtr conn = Connect_domv (domv);
1037   int r, b;
1038
1039   b = bv == Val_true ? 1 : 0;
1040
1041   NONBLOCKING (r = virDomainSetAutostart (dom, b));
1042   CHECK_ERROR (r == -1, conn, "virDomainSetAutostart");
1043
1044   CAMLreturn (Val_unit);
1045 }
1046
1047 /* Automatically generated binding for virNetworkFree.
1048  * In generator.pl this function has signature "net : free".
1049  */
1050
1051 CAMLprim value
1052 ocaml_libvirt_network_free (value netv)
1053 {
1054   CAMLparam1 (netv);
1055
1056   virNetworkPtr net = Network_val (netv);
1057   virConnectPtr conn = Connect_netv (netv);
1058   int r;
1059
1060   NONBLOCKING (r = virNetworkFree (net));
1061   CHECK_ERROR (r == -1, conn, "virNetworkFree");
1062
1063   /* So that we don't double-free in the finalizer: */
1064   Network_val (netv) = NULL;
1065
1066   CAMLreturn (Val_unit);
1067 }
1068
1069 /* Automatically generated binding for virNetworkDestroy.
1070  * In generator.pl this function has signature "net : free".
1071  */
1072
1073 CAMLprim value
1074 ocaml_libvirt_network_destroy (value netv)
1075 {
1076   CAMLparam1 (netv);
1077
1078   virNetworkPtr net = Network_val (netv);
1079   virConnectPtr conn = Connect_netv (netv);
1080   int r;
1081
1082   NONBLOCKING (r = virNetworkDestroy (net));
1083   CHECK_ERROR (r == -1, conn, "virNetworkDestroy");
1084
1085   /* So that we don't double-free in the finalizer: */
1086   Network_val (netv) = NULL;
1087
1088   CAMLreturn (Val_unit);
1089 }
1090
1091 /* Automatically generated binding for virNetworkLookupByName.
1092  * In generator.pl this function has signature "conn, string : net".
1093  */
1094
1095 CAMLprim value
1096 ocaml_libvirt_network_lookup_by_name (value connv, value strv)
1097 {
1098   CAMLparam2 (connv, strv);
1099
1100   CAMLlocal1 (rv);
1101   virConnectPtr conn = Connect_val (connv);
1102   char *str = String_val (strv);
1103   virNetworkPtr r;
1104
1105   NONBLOCKING (r = virNetworkLookupByName (conn, str));
1106   CHECK_ERROR (!r, conn, "virNetworkLookupByName");
1107
1108   rv = Val_network (r, connv);
1109
1110   CAMLreturn (rv);
1111 }
1112
1113 /* Automatically generated binding for virNetworkLookupByUUID.
1114  * In generator.pl this function has signature "conn, uuid : net".
1115  */
1116
1117 CAMLprim value
1118 ocaml_libvirt_network_lookup_by_uuid (value connv, value uuidv)
1119 {
1120   CAMLparam2 (connv, uuidv);
1121
1122   CAMLlocal1 (rv);
1123   virConnectPtr conn = Connect_val (connv);
1124   unsigned char *uuid = (unsigned char *) String_val (uuidv);
1125   virNetworkPtr r;
1126
1127   NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid));
1128   CHECK_ERROR (!r, conn, "virNetworkLookupByUUID");
1129
1130   rv = Val_network (r, connv);
1131
1132   CAMLreturn (rv);
1133 }
1134
1135 /* Automatically generated binding for virNetworkLookupByUUIDString.
1136  * In generator.pl this function has signature "conn, string : net".
1137  */
1138
1139 CAMLprim value
1140 ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv)
1141 {
1142   CAMLparam2 (connv, strv);
1143
1144   CAMLlocal1 (rv);
1145   virConnectPtr conn = Connect_val (connv);
1146   char *str = String_val (strv);
1147   virNetworkPtr r;
1148
1149   NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str));
1150   CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString");
1151
1152   rv = Val_network (r, connv);
1153
1154   CAMLreturn (rv);
1155 }
1156
1157 /* Automatically generated binding for virNetworkGetName.
1158  * In generator.pl this function has signature "net : static string".
1159  */
1160
1161 CAMLprim value
1162 ocaml_libvirt_network_get_name (value netv)
1163 {
1164   CAMLparam1 (netv);
1165
1166   CAMLlocal1 (rv);
1167   virNetworkPtr net = Network_val (netv);
1168   virConnectPtr conn = Connect_netv (netv);
1169   const char *r;
1170
1171   NONBLOCKING (r = virNetworkGetName (net));
1172   CHECK_ERROR (!r, conn, "virNetworkGetName");
1173
1174   rv = caml_copy_string (r);
1175   CAMLreturn (rv);
1176 }
1177
1178 /* Automatically generated binding for virNetworkGetXMLDesc.
1179  * In generator.pl this function has signature "net, 0 : string".
1180  */
1181
1182 CAMLprim value
1183 ocaml_libvirt_network_get_xml_desc (value netv)
1184 {
1185   CAMLparam1 (netv);
1186
1187   CAMLlocal1 (rv);
1188   virNetworkPtr net = Network_val (netv);
1189   virConnectPtr conn = Connect_netv (netv);
1190   char *r;
1191
1192   NONBLOCKING (r = virNetworkGetXMLDesc (net, 0));
1193   CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc");
1194
1195   rv = caml_copy_string (r);
1196   free (r);
1197   CAMLreturn (rv);
1198 }
1199
1200 /* Automatically generated binding for virNetworkGetBridgeName.
1201  * In generator.pl this function has signature "net : string".
1202  */
1203
1204 CAMLprim value
1205 ocaml_libvirt_network_get_bridge_name (value netv)
1206 {
1207   CAMLparam1 (netv);
1208
1209   CAMLlocal1 (rv);
1210   virNetworkPtr net = Network_val (netv);
1211   virConnectPtr conn = Connect_netv (netv);
1212   char *r;
1213
1214   NONBLOCKING (r = virNetworkGetBridgeName (net));
1215   CHECK_ERROR (!r, conn, "virNetworkGetBridgeName");
1216
1217   rv = caml_copy_string (r);
1218   free (r);
1219   CAMLreturn (rv);
1220 }
1221
1222 /* Automatically generated binding for virNetworkGetUUID.
1223  * In generator.pl this function has signature "net : uuid".
1224  */
1225
1226 CAMLprim value
1227 ocaml_libvirt_network_get_uuid (value netv)
1228 {
1229   CAMLparam1 (netv);
1230
1231   CAMLlocal1 (rv);
1232   virNetworkPtr net = Network_val (netv);
1233   virConnectPtr conn = Connect_netv (netv);
1234   unsigned char uuid[VIR_UUID_BUFLEN];
1235   int r;
1236
1237   NONBLOCKING (r = virNetworkGetUUID (net, uuid));
1238   CHECK_ERROR (r == -1, conn, "virNetworkGetUUID");
1239
1240   /* UUIDs are byte arrays with a fixed length. */
1241   rv = caml_alloc_string (VIR_UUID_BUFLEN);
1242   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
1243   CAMLreturn (rv);
1244 }
1245
1246 /* Automatically generated binding for virNetworkGetUUIDString.
1247  * In generator.pl this function has signature "net : uuid string".
1248  */
1249
1250 CAMLprim value
1251 ocaml_libvirt_network_get_uuid_string (value netv)
1252 {
1253   CAMLparam1 (netv);
1254
1255   CAMLlocal1 (rv);
1256   virNetworkPtr net = Network_val (netv);
1257   virConnectPtr conn = Connect_netv (netv);
1258   char uuid[VIR_UUID_STRING_BUFLEN];
1259   int r;
1260
1261   NONBLOCKING (r = virNetworkGetUUIDString (net, uuid));
1262   CHECK_ERROR (r == -1, conn, "virNetworkGetUUIDString");
1263
1264   rv = caml_copy_string (uuid);
1265   CAMLreturn (rv);
1266 }
1267
1268 /* Automatically generated binding for virNetworkUndefine.
1269  * In generator.pl this function has signature "net : unit".
1270  */
1271
1272 CAMLprim value
1273 ocaml_libvirt_network_undefine (value netv)
1274 {
1275   CAMLparam1 (netv);
1276
1277   virNetworkPtr net = Network_val (netv);
1278   virConnectPtr conn = Connect_netv (netv);
1279   int r;
1280
1281   NONBLOCKING (r = virNetworkUndefine (net));
1282   CHECK_ERROR (r == -1, conn, "virNetworkUndefine");
1283
1284   CAMLreturn (Val_unit);
1285 }
1286
1287 /* Automatically generated binding for virNetworkCreateXML.
1288  * In generator.pl this function has signature "conn, string : net".
1289  */
1290
1291 CAMLprim value
1292 ocaml_libvirt_network_create_xml (value connv, value strv)
1293 {
1294   CAMLparam2 (connv, strv);
1295
1296   CAMLlocal1 (rv);
1297   virConnectPtr conn = Connect_val (connv);
1298   char *str = String_val (strv);
1299   virNetworkPtr r;
1300
1301   NONBLOCKING (r = virNetworkCreateXML (conn, str));
1302   CHECK_ERROR (!r, conn, "virNetworkCreateXML");
1303
1304   rv = Val_network (r, connv);
1305
1306   CAMLreturn (rv);
1307 }
1308
1309 /* Automatically generated binding for virNetworkDefineXML.
1310  * In generator.pl this function has signature "conn, string : net".
1311  */
1312
1313 CAMLprim value
1314 ocaml_libvirt_network_define_xml (value connv, value strv)
1315 {
1316   CAMLparam2 (connv, strv);
1317
1318   CAMLlocal1 (rv);
1319   virConnectPtr conn = Connect_val (connv);
1320   char *str = String_val (strv);
1321   virNetworkPtr r;
1322
1323   NONBLOCKING (r = virNetworkDefineXML (conn, str));
1324   CHECK_ERROR (!r, conn, "virNetworkDefineXML");
1325
1326   rv = Val_network (r, connv);
1327
1328   CAMLreturn (rv);
1329 }
1330
1331 /* Automatically generated binding for virNetworkCreate.
1332  * In generator.pl this function has signature "net : unit".
1333  */
1334
1335 CAMLprim value
1336 ocaml_libvirt_network_create (value netv)
1337 {
1338   CAMLparam1 (netv);
1339
1340   virNetworkPtr net = Network_val (netv);
1341   virConnectPtr conn = Connect_netv (netv);
1342   int r;
1343
1344   NONBLOCKING (r = virNetworkCreate (net));
1345   CHECK_ERROR (r == -1, conn, "virNetworkCreate");
1346
1347   CAMLreturn (Val_unit);
1348 }
1349
1350 /* Automatically generated binding for virNetworkGetAutostart.
1351  * In generator.pl this function has signature "net : bool".
1352  */
1353
1354 CAMLprim value
1355 ocaml_libvirt_network_get_autostart (value netv)
1356 {
1357   CAMLparam1 (netv);
1358
1359   virNetworkPtr net = Network_val (netv);
1360   virConnectPtr conn = Connect_netv (netv);
1361   int r, b;
1362
1363   NONBLOCKING (r = virNetworkGetAutostart (net, &b));
1364   CHECK_ERROR (r == -1, conn, "virNetworkGetAutostart");
1365
1366   CAMLreturn (b ? Val_true : Val_false);
1367 }
1368
1369 /* Automatically generated binding for virNetworkSetAutostart.
1370  * In generator.pl this function has signature "net, bool : unit".
1371  */
1372
1373 CAMLprim value
1374 ocaml_libvirt_network_set_autostart (value netv, value bv)
1375 {
1376   CAMLparam2 (netv, bv);
1377
1378   virNetworkPtr net = Network_val (netv);
1379   virConnectPtr conn = Connect_netv (netv);
1380   int r, b;
1381
1382   b = bv == Val_true ? 1 : 0;
1383
1384   NONBLOCKING (r = virNetworkSetAutostart (net, b));
1385   CHECK_ERROR (r == -1, conn, "virNetworkSetAutostart");
1386
1387   CAMLreturn (Val_unit);
1388 }
1389
1390 /* Automatically generated binding for virStoragePoolFree.
1391  * In generator.pl this function has signature "pool : free".
1392  */
1393
1394 CAMLprim value
1395 ocaml_libvirt_storage_pool_free (value poolv)
1396 {
1397   CAMLparam1 (poolv);
1398
1399   virStoragePoolPtr pool = Pool_val (poolv);
1400   virConnectPtr conn = Connect_polv (poolv);
1401   int r;
1402
1403   NONBLOCKING (r = virStoragePoolFree (pool));
1404   CHECK_ERROR (r == -1, conn, "virStoragePoolFree");
1405
1406   /* So that we don't double-free in the finalizer: */
1407   Pool_val (poolv) = NULL;
1408
1409   CAMLreturn (Val_unit);
1410 }
1411
1412 /* Automatically generated binding for virStoragePoolDestroy.
1413  * In generator.pl this function has signature "pool : free".
1414  */
1415
1416 CAMLprim value
1417 ocaml_libvirt_storage_pool_destroy (value poolv)
1418 {
1419   CAMLparam1 (poolv);
1420
1421   virStoragePoolPtr pool = Pool_val (poolv);
1422   virConnectPtr conn = Connect_polv (poolv);
1423   int r;
1424
1425   NONBLOCKING (r = virStoragePoolDestroy (pool));
1426   CHECK_ERROR (r == -1, conn, "virStoragePoolDestroy");
1427
1428   /* So that we don't double-free in the finalizer: */
1429   Pool_val (poolv) = NULL;
1430
1431   CAMLreturn (Val_unit);
1432 }
1433
1434 /* Automatically generated binding for virStoragePoolLookupByName.
1435  * In generator.pl this function has signature "conn, string : pool".
1436  */
1437
1438 CAMLprim value
1439 ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv)
1440 {
1441   CAMLparam2 (connv, strv);
1442
1443   CAMLlocal1 (rv);
1444   virConnectPtr conn = Connect_val (connv);
1445   char *str = String_val (strv);
1446   virStoragePoolPtr r;
1447
1448   NONBLOCKING (r = virStoragePoolLookupByName (conn, str));
1449   CHECK_ERROR (!r, conn, "virStoragePoolLookupByName");
1450
1451   rv = Val_pool (r, connv);
1452
1453   CAMLreturn (rv);
1454 }
1455
1456 /* Automatically generated binding for virStoragePoolLookupByUUID.
1457  * In generator.pl this function has signature "conn, uuid : pool".
1458  */
1459
1460 CAMLprim value
1461 ocaml_libvirt_storage_pool_lookup_by_uuid (value connv, value uuidv)
1462 {
1463   CAMLparam2 (connv, uuidv);
1464
1465   CAMLlocal1 (rv);
1466   virConnectPtr conn = Connect_val (connv);
1467   unsigned char *uuid = (unsigned char *) String_val (uuidv);
1468   virStoragePoolPtr r;
1469
1470   NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid));
1471   CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID");
1472
1473   rv = Val_pool (r, connv);
1474
1475   CAMLreturn (rv);
1476 }
1477
1478 /* Automatically generated binding for virStoragePoolLookupByUUIDString.
1479  * In generator.pl this function has signature "conn, string : pool".
1480  */
1481
1482 CAMLprim value
1483 ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv)
1484 {
1485   CAMLparam2 (connv, strv);
1486
1487   CAMLlocal1 (rv);
1488   virConnectPtr conn = Connect_val (connv);
1489   char *str = String_val (strv);
1490   virStoragePoolPtr r;
1491
1492   NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str));
1493   CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString");
1494
1495   rv = Val_pool (r, connv);
1496
1497   CAMLreturn (rv);
1498 }
1499
1500 /* Automatically generated binding for virStoragePoolGetName.
1501  * In generator.pl this function has signature "pool : static string".
1502  */
1503
1504 CAMLprim value
1505 ocaml_libvirt_storage_pool_get_name (value poolv)
1506 {
1507   CAMLparam1 (poolv);
1508
1509   CAMLlocal1 (rv);
1510   virStoragePoolPtr pool = Pool_val (poolv);
1511   virConnectPtr conn = Connect_polv (poolv);
1512   const char *r;
1513
1514   NONBLOCKING (r = virStoragePoolGetName (pool));
1515   CHECK_ERROR (!r, conn, "virStoragePoolGetName");
1516
1517   rv = caml_copy_string (r);
1518   CAMLreturn (rv);
1519 }
1520
1521 /* Automatically generated binding for virStoragePoolGetXMLDesc.
1522  * In generator.pl this function has signature "pool, 0U : string".
1523  */
1524
1525 CAMLprim value
1526 ocaml_libvirt_storage_pool_get_xml_desc (value poolv)
1527 {
1528   CAMLparam1 (poolv);
1529
1530   CAMLlocal1 (rv);
1531   virStoragePoolPtr pool = Pool_val (poolv);
1532   virConnectPtr conn = Connect_polv (poolv);
1533   char *r;
1534
1535   NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0));
1536   CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc");
1537
1538   rv = caml_copy_string (r);
1539   free (r);
1540   CAMLreturn (rv);
1541 }
1542
1543 /* Automatically generated binding for virStoragePoolGetUUID.
1544  * In generator.pl this function has signature "pool : uuid".
1545  */
1546
1547 CAMLprim value
1548 ocaml_libvirt_storage_pool_get_uuid (value poolv)
1549 {
1550   CAMLparam1 (poolv);
1551
1552   CAMLlocal1 (rv);
1553   virStoragePoolPtr pool = Pool_val (poolv);
1554   virConnectPtr conn = Connect_polv (poolv);
1555   unsigned char uuid[VIR_UUID_BUFLEN];
1556   int r;
1557
1558   NONBLOCKING (r = virStoragePoolGetUUID (pool, uuid));
1559   CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUID");
1560
1561   /* UUIDs are byte arrays with a fixed length. */
1562   rv = caml_alloc_string (VIR_UUID_BUFLEN);
1563   memcpy (String_val (rv), uuid, VIR_UUID_BUFLEN);
1564   CAMLreturn (rv);
1565 }
1566
1567 /* Automatically generated binding for virStoragePoolGetUUIDString.
1568  * In generator.pl this function has signature "pool : uuid string".
1569  */
1570
1571 CAMLprim value
1572 ocaml_libvirt_storage_pool_get_uuid_string (value poolv)
1573 {
1574   CAMLparam1 (poolv);
1575
1576   CAMLlocal1 (rv);
1577   virStoragePoolPtr pool = Pool_val (poolv);
1578   virConnectPtr conn = Connect_polv (poolv);
1579   char uuid[VIR_UUID_STRING_BUFLEN];
1580   int r;
1581
1582   NONBLOCKING (r = virStoragePoolGetUUIDString (pool, uuid));
1583   CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUIDString");
1584
1585   rv = caml_copy_string (uuid);
1586   CAMLreturn (rv);
1587 }
1588
1589 /* Automatically generated binding for virStoragePoolCreateXML.
1590  * In generator.pl this function has signature "conn, string, 0U : pool".
1591  */
1592
1593 CAMLprim value
1594 ocaml_libvirt_storage_pool_create_xml (value connv, value strv)
1595 {
1596   CAMLparam2 (connv, strv);
1597
1598   CAMLlocal1 (rv);
1599   virConnectPtr conn = Connect_val (connv);
1600   char *str = String_val (strv);
1601   virStoragePoolPtr r;
1602
1603   NONBLOCKING (r = virStoragePoolCreateXML (conn, str, 0));
1604   CHECK_ERROR (!r, conn, "virStoragePoolCreateXML");
1605
1606   rv = Val_pool (r, connv);
1607
1608   CAMLreturn (rv);
1609 }
1610
1611 /* Automatically generated binding for virStoragePoolDefineXML.
1612  * In generator.pl this function has signature "conn, string, 0U : pool".
1613  */
1614
1615 CAMLprim value
1616 ocaml_libvirt_storage_pool_define_xml (value connv, value strv)
1617 {
1618   CAMLparam2 (connv, strv);
1619
1620   CAMLlocal1 (rv);
1621   virConnectPtr conn = Connect_val (connv);
1622   char *str = String_val (strv);
1623   virStoragePoolPtr r;
1624
1625   NONBLOCKING (r = virStoragePoolDefineXML (conn, str, 0));
1626   CHECK_ERROR (!r, conn, "virStoragePoolDefineXML");
1627
1628   rv = Val_pool (r, connv);
1629
1630   CAMLreturn (rv);
1631 }
1632
1633 /* Automatically generated binding for virStoragePoolBuild.
1634  * In generator.pl this function has signature "pool, uint : unit".
1635  */
1636
1637 CAMLprim value
1638 ocaml_libvirt_storage_pool_build (value poolv, value iv)
1639 {
1640   CAMLparam2 (poolv, iv);
1641
1642   virStoragePoolPtr pool = Pool_val (poolv);
1643   virConnectPtr conn = Connect_polv (poolv);
1644   unsigned int i = Int_val (iv);
1645   int r;
1646
1647   NONBLOCKING (r = virStoragePoolBuild (pool, i));
1648   CHECK_ERROR (r == -1, conn, "virStoragePoolBuild");
1649
1650   CAMLreturn (Val_unit);
1651 }
1652
1653 /* Automatically generated binding for virStoragePoolUndefine.
1654  * In generator.pl this function has signature "pool : unit".
1655  */
1656
1657 CAMLprim value
1658 ocaml_libvirt_storage_pool_undefine (value poolv)
1659 {
1660   CAMLparam1 (poolv);
1661
1662   virStoragePoolPtr pool = Pool_val (poolv);
1663   virConnectPtr conn = Connect_polv (poolv);
1664   int r;
1665
1666   NONBLOCKING (r = virStoragePoolUndefine (pool));
1667   CHECK_ERROR (r == -1, conn, "virStoragePoolUndefine");
1668
1669   CAMLreturn (Val_unit);
1670 }
1671
1672 /* Automatically generated binding for virStoragePoolCreate.
1673  * In generator.pl this function has signature "pool, 0U : unit".
1674  */
1675
1676 CAMLprim value
1677 ocaml_libvirt_storage_pool_create (value poolv)
1678 {
1679   CAMLparam1 (poolv);
1680
1681   virStoragePoolPtr pool = Pool_val (poolv);
1682   virConnectPtr conn = Connect_polv (poolv);
1683   int r;
1684
1685   NONBLOCKING (r = virStoragePoolCreate (pool, 0));
1686   CHECK_ERROR (r == -1, conn, "virStoragePoolCreate");
1687
1688   CAMLreturn (Val_unit);
1689 }
1690
1691 /* Automatically generated binding for virStoragePoolDelete.
1692  * In generator.pl this function has signature "pool, uint : unit".
1693  */
1694
1695 CAMLprim value
1696 ocaml_libvirt_storage_pool_delete (value poolv, value iv)
1697 {
1698   CAMLparam2 (poolv, iv);
1699
1700   virStoragePoolPtr pool = Pool_val (poolv);
1701   virConnectPtr conn = Connect_polv (poolv);
1702   unsigned int i = Int_val (iv);
1703   int r;
1704
1705   NONBLOCKING (r = virStoragePoolDelete (pool, i));
1706   CHECK_ERROR (r == -1, conn, "virStoragePoolDelete");
1707
1708   CAMLreturn (Val_unit);
1709 }
1710
1711 /* Automatically generated binding for virStoragePoolRefresh.
1712  * In generator.pl this function has signature "pool, 0U : unit".
1713  */
1714
1715 CAMLprim value
1716 ocaml_libvirt_storage_pool_refresh (value poolv)
1717 {
1718   CAMLparam1 (poolv);
1719
1720   virStoragePoolPtr pool = Pool_val (poolv);
1721   virConnectPtr conn = Connect_polv (poolv);
1722   int r;
1723
1724   NONBLOCKING (r = virStoragePoolRefresh (pool, 0));
1725   CHECK_ERROR (r == -1, conn, "virStoragePoolRefresh");
1726
1727   CAMLreturn (Val_unit);
1728 }
1729
1730 /* Automatically generated binding for virStoragePoolGetAutostart.
1731  * In generator.pl this function has signature "pool : bool".
1732  */
1733
1734 CAMLprim value
1735 ocaml_libvirt_storage_pool_get_autostart (value poolv)
1736 {
1737   CAMLparam1 (poolv);
1738
1739   virStoragePoolPtr pool = Pool_val (poolv);
1740   virConnectPtr conn = Connect_polv (poolv);
1741   int r, b;
1742
1743   NONBLOCKING (r = virStoragePoolGetAutostart (pool, &b));
1744   CHECK_ERROR (r == -1, conn, "virStoragePoolGetAutostart");
1745
1746   CAMLreturn (b ? Val_true : Val_false);
1747 }
1748
1749 /* Automatically generated binding for virStoragePoolSetAutostart.
1750  * In generator.pl this function has signature "pool, bool : unit".
1751  */
1752
1753 CAMLprim value
1754 ocaml_libvirt_storage_pool_set_autostart (value poolv, value bv)
1755 {
1756   CAMLparam2 (poolv, bv);
1757
1758   virStoragePoolPtr pool = Pool_val (poolv);
1759   virConnectPtr conn = Connect_polv (poolv);
1760   int r, b;
1761
1762   b = bv == Val_true ? 1 : 0;
1763
1764   NONBLOCKING (r = virStoragePoolSetAutostart (pool, b));
1765   CHECK_ERROR (r == -1, conn, "virStoragePoolSetAutostart");
1766
1767   CAMLreturn (Val_unit);
1768 }
1769
1770 /* Automatically generated binding for virStoragePoolNumOfVolumes.
1771  * In generator.pl this function has signature "pool : int".
1772  */
1773
1774 CAMLprim value
1775 ocaml_libvirt_storage_pool_num_of_volumes (value poolv)
1776 {
1777   CAMLparam1 (poolv);
1778
1779   virStoragePoolPtr pool = Pool_val (poolv);
1780   virConnectPtr conn = Connect_polv (poolv);
1781   int r;
1782
1783   NONBLOCKING (r = virStoragePoolNumOfVolumes (pool));
1784   CHECK_ERROR (r == -1, conn, "virStoragePoolNumOfVolumes");
1785
1786   CAMLreturn (Val_int (r));
1787 }
1788
1789 /* Automatically generated binding for virStoragePoolListVolumes.
1790  * In generator.pl this function has signature "pool, int : string array".
1791  */
1792
1793 CAMLprim value
1794 ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv)
1795 {
1796   CAMLparam2 (poolv, iv);
1797
1798   CAMLlocal2 (rv, strv);
1799   virStoragePoolPtr pool = Pool_val (poolv);
1800   virConnectPtr conn = Connect_polv (poolv);
1801   int i = Int_val (iv);
1802   char *names[i];
1803   int r;
1804
1805   /* Some libvirt List* functions still throw exceptions if i == 0,
1806    * so catch that and return an empty array directly.  This changes
1807    * the semantics slightly (masking other failures) but it's
1808    * unlikely anyone will care.  RWMJ 2008/06/10
1809    */
1810   if (i == 0) {
1811     rv = caml_alloc (0, 0);
1812     CAMLreturn (rv);
1813   }
1814
1815   NONBLOCKING (r = virStoragePoolListVolumes (pool, names, i));
1816   CHECK_ERROR (r == -1, conn, "virStoragePoolListVolumes");
1817
1818   rv = caml_alloc (r, 0);
1819   for (i = 0; i < r; ++i) {
1820     strv = caml_copy_string (names[i]);
1821     Store_field (rv, i, strv);
1822     free (names[i]);
1823   }
1824
1825   CAMLreturn (rv);
1826 }
1827
1828 /* Automatically generated binding for virStorageVolFree.
1829  * In generator.pl this function has signature "vol : free".
1830  */
1831
1832 CAMLprim value
1833 ocaml_libvirt_storage_vol_free (value volv)
1834 {
1835   CAMLparam1 (volv);
1836
1837   virStorageVolPtr vol = Volume_val (volv);
1838   virConnectPtr conn = Connect_volv (volv);
1839   int r;
1840
1841   NONBLOCKING (r = virStorageVolFree (vol));
1842   CHECK_ERROR (r == -1, conn, "virStorageVolFree");
1843
1844   /* So that we don't double-free in the finalizer: */
1845   Volume_val (volv) = NULL;
1846
1847   CAMLreturn (Val_unit);
1848 }
1849
1850 /* Automatically generated binding for virStorageVolDelete.
1851  * In generator.pl this function has signature "vol, uint : unit".
1852  */
1853
1854 CAMLprim value
1855 ocaml_libvirt_storage_vol_delete (value volv, value iv)
1856 {
1857   CAMLparam2 (volv, iv);
1858
1859   virStorageVolPtr vol = Volume_val (volv);
1860   virConnectPtr conn = Connect_volv (volv);
1861   unsigned int i = Int_val (iv);
1862   int r;
1863
1864   NONBLOCKING (r = virStorageVolDelete (vol, i));
1865   CHECK_ERROR (r == -1, conn, "virStorageVolDelete");
1866
1867   CAMLreturn (Val_unit);
1868 }
1869
1870 /* Automatically generated binding for virStorageVolLookupByName.
1871  * In generator.pl this function has signature "pool, string : vol from pool".
1872  */
1873
1874 CAMLprim value
1875 ocaml_libvirt_storage_vol_lookup_by_name (value poolv, value strv)
1876 {
1877   CAMLparam2 (poolv, strv);
1878
1879   CAMLlocal2 (rv, connv);
1880   virStoragePoolPtr pool = Pool_val (poolv);
1881   virConnectPtr conn = Connect_polv (poolv);
1882   char *str = String_val (strv);
1883   virStorageVolPtr r;
1884
1885   NONBLOCKING (r = virStorageVolLookupByName (pool, str));
1886   CHECK_ERROR (!r, conn, "virStorageVolLookupByName");
1887
1888   connv = Field (poolv, 1);
1889   rv = Val_volume (r, connv);
1890
1891   CAMLreturn (rv);
1892 }
1893
1894 /* Automatically generated binding for virStorageVolLookupByKey.
1895  * In generator.pl this function has signature "conn, string : vol".
1896  */
1897
1898 CAMLprim value
1899 ocaml_libvirt_storage_vol_lookup_by_key (value connv, value strv)
1900 {
1901   CAMLparam2 (connv, strv);
1902
1903   CAMLlocal1 (rv);
1904   virConnectPtr conn = Connect_val (connv);
1905   char *str = String_val (strv);
1906   virStorageVolPtr r;
1907
1908   NONBLOCKING (r = virStorageVolLookupByKey (conn, str));
1909   CHECK_ERROR (!r, conn, "virStorageVolLookupByKey");
1910
1911   rv = Val_volume (r, connv);
1912
1913   CAMLreturn (rv);
1914 }
1915
1916 /* Automatically generated binding for virStorageVolLookupByPath.
1917  * In generator.pl this function has signature "conn, string : vol".
1918  */
1919
1920 CAMLprim value
1921 ocaml_libvirt_storage_vol_lookup_by_path (value connv, value strv)
1922 {
1923   CAMLparam2 (connv, strv);
1924
1925   CAMLlocal1 (rv);
1926   virConnectPtr conn = Connect_val (connv);
1927   char *str = String_val (strv);
1928   virStorageVolPtr r;
1929
1930   NONBLOCKING (r = virStorageVolLookupByPath (conn, str));
1931   CHECK_ERROR (!r, conn, "virStorageVolLookupByPath");
1932
1933   rv = Val_volume (r, connv);
1934
1935   CAMLreturn (rv);
1936 }
1937
1938 /* Automatically generated binding for virStorageVolCreateXML.
1939  * In generator.pl this function has signature "pool, string, 0U : vol from pool".
1940  */
1941
1942 CAMLprim value
1943 ocaml_libvirt_storage_vol_create_xml (value poolv, value strv)
1944 {
1945   CAMLparam2 (poolv, strv);
1946
1947   CAMLlocal2 (rv, connv);
1948   virStoragePoolPtr pool = Pool_val (poolv);
1949   virConnectPtr conn = Connect_polv (poolv);
1950   char *str = String_val (strv);
1951   virStorageVolPtr r;
1952
1953   NONBLOCKING (r = virStorageVolCreateXML (pool, str, 0));
1954   CHECK_ERROR (!r, conn, "virStorageVolCreateXML");
1955
1956   connv = Field (poolv, 1);
1957   rv = Val_volume (r, connv);
1958
1959   CAMLreturn (rv);
1960 }
1961
1962 /* Automatically generated binding for virStorageVolGetXMLDesc.
1963  * In generator.pl this function has signature "vol, 0U : string".
1964  */
1965
1966 CAMLprim value
1967 ocaml_libvirt_storage_vol_get_xml_desc (value volv)
1968 {
1969   CAMLparam1 (volv);
1970
1971   CAMLlocal1 (rv);
1972   virStorageVolPtr vol = Volume_val (volv);
1973   virConnectPtr conn = Connect_volv (volv);
1974   char *r;
1975
1976   NONBLOCKING (r = virStorageVolGetXMLDesc (vol, 0));
1977   CHECK_ERROR (!r, conn, "virStorageVolGetXMLDesc");
1978
1979   rv = caml_copy_string (r);
1980   free (r);
1981   CAMLreturn (rv);
1982 }
1983
1984 /* Automatically generated binding for virStorageVolGetPath.
1985  * In generator.pl this function has signature "vol : string".
1986  */
1987
1988 CAMLprim value
1989 ocaml_libvirt_storage_vol_get_path (value volv)
1990 {
1991   CAMLparam1 (volv);
1992
1993   CAMLlocal1 (rv);
1994   virStorageVolPtr vol = Volume_val (volv);
1995   virConnectPtr conn = Connect_volv (volv);
1996   char *r;
1997
1998   NONBLOCKING (r = virStorageVolGetPath (vol));
1999   CHECK_ERROR (!r, conn, "virStorageVolGetPath");
2000
2001   rv = caml_copy_string (r);
2002   free (r);
2003   CAMLreturn (rv);
2004 }
2005
2006 /* Automatically generated binding for virStorageVolGetKey.
2007  * In generator.pl this function has signature "vol : static string".
2008  */
2009
2010 CAMLprim value
2011 ocaml_libvirt_storage_vol_get_key (value volv)
2012 {
2013   CAMLparam1 (volv);
2014
2015   CAMLlocal1 (rv);
2016   virStorageVolPtr vol = Volume_val (volv);
2017   virConnectPtr conn = Connect_volv (volv);
2018   const char *r;
2019
2020   NONBLOCKING (r = virStorageVolGetKey (vol));
2021   CHECK_ERROR (!r, conn, "virStorageVolGetKey");
2022
2023   rv = caml_copy_string (r);
2024   CAMLreturn (rv);
2025 }
2026
2027 /* Automatically generated binding for virStorageVolGetName.
2028  * In generator.pl this function has signature "vol : static string".
2029  */
2030
2031 CAMLprim value
2032 ocaml_libvirt_storage_vol_get_name (value volv)
2033 {
2034   CAMLparam1 (volv);
2035
2036   CAMLlocal1 (rv);
2037   virStorageVolPtr vol = Volume_val (volv);
2038   virConnectPtr conn = Connect_volv (volv);
2039   const char *r;
2040
2041   NONBLOCKING (r = virStorageVolGetName (vol));
2042   CHECK_ERROR (!r, conn, "virStorageVolGetName");
2043
2044   rv = caml_copy_string (r);
2045   CAMLreturn (rv);
2046 }
2047
2048 /* Automatically generated binding for virStoragePoolLookupByVolume.
2049  * In generator.pl this function has signature "vol : pool from vol".
2050  */
2051
2052 CAMLprim value
2053 ocaml_libvirt_storage_pool_lookup_by_volume (value volv)
2054 {
2055   CAMLparam1 (volv);
2056
2057   CAMLlocal2 (rv, connv);
2058   virStorageVolPtr vol = Volume_val (volv);
2059   virConnectPtr conn = Connect_volv (volv);
2060   virStoragePoolPtr r;
2061
2062   NONBLOCKING (r = virStoragePoolLookupByVolume (vol));
2063   CHECK_ERROR (!r, conn, "virStoragePoolLookupByVolume");
2064
2065   connv = Field (volv, 1);
2066   rv = Val_pool (r, connv);
2067
2068   CAMLreturn (rv);
2069 }
2070
2071 #include "libvirt_c_epilogue.c"
2072
2073 /* EOF */