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