src/dma/vendor/github.com/libvirt/libvirt-go/domain_wrapper.go

   1 /*
   2  * This file is part of the libvirt-go project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * Copyright (c) 2013 Alex Zorin
  23  * Copyright (C) 2016 Red Hat, Inc.
  24  *
  25  */
  26
  27 package libvirt
  28
  29 /*
  30 #cgo pkg-config: libvirt
  31 #include <assert.h>
  32 #include "domain_wrapper.h"
  33
  34 int
  35 virDomainAbortJobWrapper(virDomainPtr domain,
  36                          virErrorPtr err)
  37 {
  38     int ret = virDomainAbortJob(domain);
  39     if (ret < 0) {
  40         virCopyLastError(err);
  41     }
  42     return ret;
  43 }
  44
  45
  46 int
  47 virDomainAddIOThreadWrapper(virDomainPtr domain,
  48                             unsigned int iothread_id,
  49                             unsigned int flags,
  50                             virErrorPtr err)
  51 {
  52 #if LIBVIR_VERSION_NUMBER < 1002015
  53     assert(0); // Caller should have checked version
  54 #else
  55     int ret = virDomainAddIOThread(domain, iothread_id, flags);
  56     if (ret < 0) {
  57         virCopyLastError(err);
  58     }
  59     return ret;
  60 #endif
  61 }
  62
  63
  64 int
  65 virDomainAttachDeviceWrapper(virDomainPtr domain,
  66                              const char *xml,
  67                              virErrorPtr err)
  68 {
  69     int ret = virDomainAttachDevice(domain, xml);
  70     if (ret < 0) {
  71         virCopyLastError(err);
  72     }
  73     return ret;
  74 }
  75
  76
  77 int
  78 virDomainAttachDeviceFlagsWrapper(virDomainPtr domain,
  79                                   const char *xml,
  80                                   unsigned int flags,
  81                                   virErrorPtr err)
  82 {
  83     int ret = virDomainAttachDeviceFlags(domain, xml, flags);
  84     if (ret < 0) {
  85         virCopyLastError(err);
  86     }
  87     return ret;
  88 }
  89
  90
  91 int
  92 virDomainBlockCommitWrapper(virDomainPtr dom,
  93                             const char *disk,
  94                             const char *base,
  95                             const char *top,
  96                             unsigned long bandwidth,
  97                             unsigned int flags,
  98                             virErrorPtr err)
  99 {
 100     int ret = virDomainBlockCommit(dom, disk, base, top, bandwidth, flags);
 101     if (ret < 0) {
 102         virCopyLastError(err);
 103     }
 104     return ret;
 105 }
 106
 107
 108 int
 109 virDomainBlockCopyWrapper(virDomainPtr dom,
 110                           const char *disk,
 111                           const char *destxml,
 112                           virTypedParameterPtr params,
 113                           int nparams,
 114                           unsigned int flags,
 115                           virErrorPtr err)
 116 {
 117 #if LIBVIR_VERSION_NUMBER < 1002008
 118     assert(0); // Caller should have checked version
 119 #else
 120     int ret = virDomainBlockCopy(dom, disk, destxml, params, nparams, flags);
 121     if (ret < 0) {
 122         virCopyLastError(err);
 123     }
 124     return ret;
 125 #endif
 126 }
 127
 128
 129 int
 130 virDomainBlockJobAbortWrapper(virDomainPtr dom,
 131                               const char *disk,
 132                               unsigned int flags,
 133                               virErrorPtr err)
 134 {
 135     int ret = virDomainBlockJobAbort(dom, disk, flags);
 136     if (ret < 0) {
 137         virCopyLastError(err);
 138     }
 139     return ret;
 140 }
 141
 142
 143 int
 144 virDomainBlockJobSetSpeedWrapper(virDomainPtr dom,
 145                                  const char *disk,
 146                                  unsigned long bandwidth,
 147                                  unsigned int flags,
 148                                  virErrorPtr err)
 149 {
 150     int ret = virDomainBlockJobSetSpeed(dom, disk, bandwidth, flags);
 151     if (ret < 0) {
 152         virCopyLastError(err);
 153     }
 154     return ret;
 155 }
 156
 157
 158 int
 159 virDomainBlockPeekWrapper(virDomainPtr dom,
 160                           const char *disk,
 161                           unsigned long long offset,
 162                           size_t size,
 163                           void *buffer,
 164                           unsigned int flags,
 165                           virErrorPtr err)
 166 {
 167     int ret = virDomainBlockPeek(dom, disk, offset, size, buffer, flags);
 168     if (ret < 0) {
 169         virCopyLastError(err);
 170     }
 171     return ret;
 172 }
 173
 174
 175 int
 176 virDomainBlockPullWrapper(virDomainPtr dom,
 177                           const char *disk,
 178                           unsigned long bandwidth,
 179                           unsigned int flags,
 180                           virErrorPtr err)
 181 {
 182     int ret = virDomainBlockPull(dom, disk, bandwidth, flags);
 183     if (ret < 0) {
 184         virCopyLastError(err);
 185     }
 186     return ret;
 187 }
 188
 189
 190 int
 191 virDomainBlockRebaseWrapper(virDomainPtr dom,
 192                             const char *disk,
 193                             const char *base,
 194                             unsigned long bandwidth,
 195                             unsigned int flags,
 196                             virErrorPtr err)
 197 {
 198     int ret = virDomainBlockRebase(dom, disk, base, bandwidth, flags);
 199     if (ret < 0) {
 200         virCopyLastError(err);
 201     }
 202     return ret;
 203 }
 204
 205
 206 int
 207 virDomainBlockResizeWrapper(virDomainPtr dom,
 208                             const char *disk,
 209                             unsigned long long size,
 210                             unsigned int flags,
 211                             virErrorPtr err)
 212 {
 213     int ret = virDomainBlockResize(dom, disk, size, flags);
 214     if (ret < 0) {
 215         virCopyLastError(err);
 216     }
 217     return ret;
 218 }
 219
 220
 221 int
 222 virDomainBlockStatsWrapper(virDomainPtr dom,
 223                            const char *disk,
 224                            virDomainBlockStatsPtr stats,
 225                            size_t size,
 226                            virErrorPtr err)
 227 {
 228     int ret = virDomainBlockStats(dom, disk, stats, size);
 229     if (ret < 0) {
 230         virCopyLastError(err);
 231     }
 232     return ret;
 233 }
 234
 235
 236 int
 237 virDomainBlockStatsFlagsWrapper(virDomainPtr dom,
 238                                 const char *disk,
 239                                 virTypedParameterPtr params,
 240                                 int *nparams,
 241                                 unsigned int flags,
 242                                 virErrorPtr err)
 243 {
 244     int ret = virDomainBlockStatsFlags(dom, disk, params, nparams, flags);
 245     if (ret < 0) {
 246         virCopyLastError(err);
 247     }
 248     return ret;
 249 }
 250
 251
 252 int
 253 virDomainCoreDumpWrapper(virDomainPtr domain,
 254                          const char *to,
 255                          unsigned int flags,
 256                          virErrorPtr err)
 257 {
 258     int ret = virDomainCoreDump(domain, to, flags);
 259     if (ret < 0) {
 260         virCopyLastError(err);
 261     }
 262     return ret;
 263 }
 264
 265
 266 int
 267 virDomainCoreDumpWithFormatWrapper(virDomainPtr domain,
 268                                    const char *to,
 269                                    unsigned int dumpformat,
 270                                    unsigned int flags,
 271                                    virErrorPtr err)
 272 {
 273 #if LIBVIR_VERSION_NUMBER < 1002003
 274     assert(0); // Caller should have checked version
 275 #else
 276     int ret = virDomainCoreDumpWithFormat(domain, to, dumpformat, flags);
 277     if (ret < 0) {
 278         virCopyLastError(err);
 279     }
 280     return ret;
 281 #endif
 282 }
 283
 284
 285 int
 286 virDomainCreateWrapper(virDomainPtr domain,
 287                        virErrorPtr err)
 288 {
 289     int ret = virDomainCreate(domain);
 290     if (ret < 0) {
 291         virCopyLastError(err);
 292     }
 293     return ret;
 294 }
 295
 296
 297 int
 298 virDomainCreateWithFilesWrapper(virDomainPtr domain,
 299                                 unsigned int nfiles,
 300                                 int *files,
 301                                 unsigned int flags,
 302                                 virErrorPtr err)
 303 {
 304     int ret = virDomainCreateWithFiles(domain, nfiles, files, flags);
 305     if (ret < 0) {
 306         virCopyLastError(err);
 307     }
 308     return ret;
 309 }
 310
 311
 312 int
 313 virDomainCreateWithFlagsWrapper(virDomainPtr domain,
 314                                 unsigned int flags,
 315                                 virErrorPtr err)
 316 {
 317     int ret = virDomainCreateWithFlags(domain, flags);
 318     if (ret < 0) {
 319         virCopyLastError(err);
 320     }
 321     return ret;
 322 }
 323
 324
 325 int
 326 virDomainDelIOThreadWrapper(virDomainPtr domain,
 327                             unsigned int iothread_id,
 328                             unsigned int flags,
 329                             virErrorPtr err)
 330 {
 331 #if LIBVIR_VERSION_NUMBER < 1002015
 332     assert(0); // Caller should have checked version
 333 #else
 334     int ret = virDomainDelIOThread(domain, iothread_id, flags);
 335     if (ret < 0) {
 336         virCopyLastError(err);
 337     }
 338     return ret;
 339 #endif
 340 }
 341
 342
 343 int
 344 virDomainDestroyWrapper(virDomainPtr domain,
 345                         virErrorPtr err)
 346 {
 347     int ret = virDomainDestroy(domain);
 348     if (ret < 0) {
 349         virCopyLastError(err);
 350     }
 351     return ret;
 352 }
 353
 354
 355 int
 356 virDomainDestroyFlagsWrapper(virDomainPtr domain,
 357                              unsigned int flags,
 358                              virErrorPtr err)
 359 {
 360     int ret = virDomainDestroyFlags(domain, flags);
 361     if (ret < 0) {
 362         virCopyLastError(err);
 363     }
 364     return ret;
 365 }
 366
 367
 368 int
 369 virDomainDetachDeviceWrapper(virDomainPtr domain,
 370                              const char *xml,
 371                              virErrorPtr err)
 372 {
 373     int ret = virDomainDetachDevice(domain, xml);
 374     if (ret < 0) {
 375         virCopyLastError(err);
 376     }
 377     return ret;
 378 }
 379
 380
 381 int
 382 virDomainDetachDeviceAliasWrapper(virDomainPtr domain,
 383                                   const char *alias,
 384                                   unsigned int flags,
 385                                   virErrorPtr err)
 386 {
 387 #if LIBVIR_VERSION_NUMBER < 4004000
 388     assert(0); // Caller should have checked version
 389 #else
 390     int ret = virDomainDetachDeviceAlias(domain, alias, flags);
 391     if (ret < 0) {
 392         virCopyLastError(err);
 393     }
 394     return ret;
 395 #endif
 396 }
 397
 398
 399 int
 400 virDomainDetachDeviceFlagsWrapper(virDomainPtr domain,
 401                                   const char *xml,
 402                                   unsigned int flags,
 403                                   virErrorPtr err)
 404 {
 405     int ret = virDomainDetachDeviceFlags(domain, xml, flags);
 406     if (ret < 0) {
 407         virCopyLastError(err);
 408     }
 409     return ret;
 410 }
 411
 412
 413 int
 414 virDomainFSFreezeWrapper(virDomainPtr dom,
 415                          const char **mountpoints,
 416                          unsigned int nmountpoints,
 417                          unsigned int flags,
 418                          virErrorPtr err)
 419 {
 420 #if LIBVIR_VERSION_NUMBER < 1002005
 421     assert(0); // Caller should have checked version
 422 #else
 423     int ret = virDomainFSFreeze(dom, mountpoints, nmountpoints, flags);
 424     if (ret < 0) {
 425         virCopyLastError(err);
 426     }
 427     return ret;
 428 #endif
 429 }
 430
 431
 432 void
 433 virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info)
 434 {
 435 #if LIBVIR_VERSION_NUMBER < 1002011
 436     assert(0); // Caller should have checked version
 437 #else
 438     virDomainFSInfoFree(info);
 439 #endif
 440 }
 441
 442
 443 int
 444 virDomainFSThawWrapper(virDomainPtr dom,
 445                        const char **mountpoints,
 446                        unsigned int nmountpoints,
 447                        unsigned int flags,
 448                        virErrorPtr err)
 449 {
 450 #if LIBVIR_VERSION_NUMBER < 1002005
 451     assert(0); // Caller should have checked version
 452 #else
 453     int ret = virDomainFSThaw(dom, mountpoints, nmountpoints, flags);
 454     if (ret < 0) {
 455         virCopyLastError(err);
 456     }
 457     return ret;
 458 #endif
 459 }
 460
 461
 462 int
 463 virDomainFSTrimWrapper(virDomainPtr dom,
 464                        const char *mountPoint,
 465                        unsigned long long minimum,
 466                        unsigned int flags,
 467                        virErrorPtr err)
 468 {
 469     int ret = virDomainFSTrim(dom, mountPoint, minimum, flags);
 470     if (ret < 0) {
 471         virCopyLastError(err);
 472     }
 473     return ret;
 474 }
 475
 476
 477 int
 478 virDomainFreeWrapper(virDomainPtr domain,
 479                      virErrorPtr err)
 480 {
 481     int ret = virDomainFree(domain);
 482     if (ret < 0) {
 483         virCopyLastError(err);
 484     }
 485     return ret;
 486 }
 487
 488
 489 int
 490 virDomainGetAutostartWrapper(virDomainPtr domain,
 491                              int *autostart,
 492                              virErrorPtr err)
 493 {
 494     int ret = virDomainGetAutostart(domain, autostart);
 495     if (ret < 0) {
 496         virCopyLastError(err);
 497     }
 498     return ret;
 499 }
 500
 501
 502 int
 503 virDomainGetBlkioParametersWrapper(virDomainPtr domain,
 504                                    virTypedParameterPtr params,
 505                                    int *nparams,
 506                                    unsigned int flags,
 507                                    virErrorPtr err)
 508 {
 509     int ret = virDomainGetBlkioParameters(domain, params, nparams, flags);
 510     if (ret < 0) {
 511         virCopyLastError(err);
 512     }
 513     return ret;
 514 }
 515
 516
 517 int
 518 virDomainGetBlockInfoWrapper(virDomainPtr domain,
 519                              const char *disk,
 520                              virDomainBlockInfoPtr info,
 521                              unsigned int flags,
 522                              virErrorPtr err)
 523 {
 524     int ret = virDomainGetBlockInfo(domain, disk, info, flags);
 525     if (ret < 0) {
 526         virCopyLastError(err);
 527     }
 528     return ret;
 529 }
 530
 531
 532 int
 533 virDomainGetBlockIoTuneWrapper(virDomainPtr dom,
 534                                const char *disk,
 535                                virTypedParameterPtr params,
 536                                int *nparams,
 537                                unsigned int flags,
 538                                virErrorPtr err)
 539 {
 540     int ret = virDomainGetBlockIoTune(dom, disk, params, nparams, flags);
 541     if (ret < 0) {
 542         virCopyLastError(err);
 543     }
 544     return ret;
 545 }
 546
 547
 548 int
 549 virDomainGetBlockJobInfoWrapper(virDomainPtr dom,
 550                                 const char *disk,
 551                                 virDomainBlockJobInfoPtr info,
 552                                 unsigned int flags,
 553                                 virErrorPtr err)
 554 {
 555     int ret = virDomainGetBlockJobInfo(dom, disk, info, flags);
 556     if (ret < 0) {
 557         virCopyLastError(err);
 558     }
 559     return ret;
 560 }
 561
 562
 563 int
 564 virDomainGetCPUStatsWrapper(virDomainPtr domain,
 565                             virTypedParameterPtr params,
 566                             unsigned int nparams,
 567                             int start_cpu,
 568                             unsigned int ncpus,
 569                             unsigned int flags,
 570                             virErrorPtr err)
 571 {
 572     int ret = virDomainGetCPUStats(domain, params, nparams, start_cpu, ncpus, flags);
 573     if (ret < 0) {
 574         virCopyLastError(err);
 575     }
 576     return ret;
 577 }
 578
 579
 580 virConnectPtr
 581 virDomainGetConnectWrapper(virDomainPtr dom,
 582                            virErrorPtr err)
 583 {
 584     virConnectPtr ret = virDomainGetConnect(dom);
 585     if (!ret) {
 586         virCopyLastError(err);
 587     }
 588     return ret;
 589 }
 590
 591
 592 int
 593 virDomainGetControlInfoWrapper(virDomainPtr domain,
 594                                virDomainControlInfoPtr info,
 595                                unsigned int flags,
 596                                virErrorPtr err)
 597 {
 598     int ret = virDomainGetControlInfo(domain, info, flags);
 599     if (ret < 0) {
 600         virCopyLastError(err);
 601     }
 602     return ret;
 603 }
 604
 605
 606 int
 607 virDomainGetDiskErrorsWrapper(virDomainPtr dom,
 608                               virDomainDiskErrorPtr errors,
 609                               unsigned int maxerrors,
 610                               unsigned int flags,
 611                               virErrorPtr err)
 612 {
 613     int ret = virDomainGetDiskErrors(dom, errors, maxerrors, flags);
 614     if (ret < 0) {
 615         virCopyLastError(err);
 616     }
 617     return ret;
 618 }
 619
 620
 621 int
 622 virDomainGetEmulatorPinInfoWrapper(virDomainPtr domain,
 623                                    unsigned char *cpumap,
 624                                    int maplen,
 625                                    unsigned int flags,
 626                                    virErrorPtr err)
 627 {
 628     int ret = virDomainGetEmulatorPinInfo(domain, cpumap, maplen, flags);
 629     if (ret < 0) {
 630         virCopyLastError(err);
 631     }
 632     return ret;
 633 }
 634
 635
 636 int
 637 virDomainGetFSInfoWrapper(virDomainPtr dom,
 638                           virDomainFSInfoPtr **info,
 639                           unsigned int flags,
 640                           virErrorPtr err)
 641 {
 642 #if LIBVIR_VERSION_NUMBER < 1002011
 643     assert(0); // Caller should have checked version
 644 #else
 645     int ret = virDomainGetFSInfo(dom, info, flags);
 646     if (ret < 0) {
 647         virCopyLastError(err);
 648     }
 649     return ret;
 650 #endif
 651 }
 652
 653
 654 int
 655 virDomainGetGuestVcpusWrapper(virDomainPtr domain,
 656                               virTypedParameterPtr *params,
 657                               unsigned int *nparams,
 658                               unsigned int flags,
 659                               virErrorPtr err)
 660 {
 661 #if LIBVIR_VERSION_NUMBER < 2000000
 662     assert(0); // Caller should have checked version
 663 #else
 664     int ret = virDomainGetGuestVcpus(domain, params, nparams, flags);
 665     if (ret < 0) {
 666         virCopyLastError(err);
 667     }
 668     return ret;
 669 #endif
 670 }
 671
 672
 673 char *
 674 virDomainGetHostnameWrapper(virDomainPtr domain,
 675                             unsigned int flags,
 676                             virErrorPtr err)
 677 {
 678     char * ret = virDomainGetHostname(domain, flags);
 679     if (!ret) {
 680         virCopyLastError(err);
 681     }
 682     return ret;
 683 }
 684
 685
 686 unsigned int
 687 virDomainGetIDWrapper(virDomainPtr domain,
 688                       virErrorPtr err)
 689 {
 690     unsigned int ret = virDomainGetID(domain);
 691     if (ret == (unsigned int)-1) {
 692         virCopyLastError(err);
 693     }
 694     return ret;
 695 }
 696
 697
 698 int
 699 virDomainGetIOThreadInfoWrapper(virDomainPtr dom,
 700                                 virDomainIOThreadInfoPtr **info,
 701                                 unsigned int flags,
 702                                 virErrorPtr err)
 703 {
 704 #if LIBVIR_VERSION_NUMBER < 1002014
 705     assert(0); // Caller should have checked version
 706 #else
 707     int ret = virDomainGetIOThreadInfo(dom, info, flags);
 708     if (ret < 0) {
 709         virCopyLastError(err);
 710     }
 711     return ret;
 712 #endif
 713 }
 714
 715
 716 int
 717 virDomainGetInfoWrapper(virDomainPtr domain,
 718                         virDomainInfoPtr info,
 719                         virErrorPtr err)
 720 {
 721     int ret = virDomainGetInfo(domain, info);
 722     if (ret < 0) {
 723         virCopyLastError(err);
 724     }
 725     return ret;
 726 }
 727
 728
 729 int
 730 virDomainGetInterfaceParametersWrapper(virDomainPtr domain,
 731                                        const char *device,
 732                                        virTypedParameterPtr params,
 733                                        int *nparams,
 734                                        unsigned int flags,
 735                                        virErrorPtr err)
 736 {
 737     int ret = virDomainGetInterfaceParameters(domain, device, params, nparams, flags);
 738     if (ret < 0) {
 739         virCopyLastError(err);
 740     }
 741     return ret;
 742 }
 743
 744
 745 int
 746 virDomainGetJobInfoWrapper(virDomainPtr domain,
 747                            virDomainJobInfoPtr info,
 748                            virErrorPtr err)
 749 {
 750     int ret = virDomainGetJobInfo(domain, info);
 751     if (ret < 0) {
 752         virCopyLastError(err);
 753     }
 754     return ret;
 755 }
 756
 757
 758 int
 759 virDomainGetJobStatsWrapper(virDomainPtr domain,
 760                             int *type,
 761                             virTypedParameterPtr *params,
 762                             int *nparams,
 763                             unsigned int flags,
 764                             virErrorPtr err)
 765 {
 766     int ret = virDomainGetJobStats(domain, type, params, nparams, flags);
 767     if (ret < 0) {
 768         virCopyLastError(err);
 769     }
 770     return ret;
 771 }
 772
 773
 774 int
 775 virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain,
 776                                       virTypedParameterPtr *params,
 777                                       int *nparams,
 778                                       unsigned int flags,
 779                                       virErrorPtr err)
 780 {
 781 #if LIBVIR_VERSION_NUMBER < 4005000
 782     assert(0); // Caller should have checked version
 783 #else
 784     int ret = virDomainGetLaunchSecurityInfo(domain, params, nparams, flags);
 785     if (ret < 0) {
 786         virCopyLastError(err);
 787     }
 788     return ret;
 789 #endif
 790 }
 791
 792
 793 unsigned long
 794 virDomainGetMaxMemoryWrapper(virDomainPtr domain,
 795                              virErrorPtr err)
 796 {
 797     unsigned long ret = virDomainGetMaxMemory(domain);
 798     if (ret == 0) {
 799         virCopyLastError(err);
 800     }
 801     return ret;
 802 }
 803
 804
 805 int
 806 virDomainGetMaxVcpusWrapper(virDomainPtr domain,
 807                             virErrorPtr err)
 808 {
 809     int ret = virDomainGetMaxVcpus(domain);
 810     if (ret < 0) {
 811         virCopyLastError(err);
 812     }
 813     return ret;
 814 }
 815
 816
 817 int
 818 virDomainGetMemoryParametersWrapper(virDomainPtr domain,
 819                                     virTypedParameterPtr params,
 820                                     int *nparams,
 821                                     unsigned int flags,
 822                                     virErrorPtr err)
 823 {
 824     int ret = virDomainGetMemoryParameters(domain, params, nparams, flags);
 825     if (ret < 0) {
 826         virCopyLastError(err);
 827     }
 828     return ret;
 829 }
 830
 831
 832 char *
 833 virDomainGetMetadataWrapper(virDomainPtr domain,
 834                             int type,
 835                             const char *uri,
 836                             unsigned int flags,
 837                             virErrorPtr err)
 838 {
 839     char * ret = virDomainGetMetadata(domain, type, uri, flags);
 840     if (!ret) {
 841         virCopyLastError(err);
 842     }
 843     return ret;
 844 }
 845
 846
 847 const char *
 848 virDomainGetNameWrapper(virDomainPtr domain,
 849                         virErrorPtr err)
 850 {
 851     const char * ret = virDomainGetName(domain);
 852     if (!ret) {
 853         virCopyLastError(err);
 854     }
 855     return ret;
 856 }
 857
 858
 859 int
 860 virDomainGetNumaParametersWrapper(virDomainPtr domain,
 861                                   virTypedParameterPtr params,
 862                                   int *nparams,
 863                                   unsigned int flags,
 864                                   virErrorPtr err)
 865 {
 866     int ret = virDomainGetNumaParameters(domain, params, nparams, flags);
 867     if (ret < 0) {
 868         virCopyLastError(err);
 869     }
 870     return ret;
 871 }
 872
 873
 874 char *
 875 virDomainGetOSTypeWrapper(virDomainPtr domain,
 876                           virErrorPtr err)
 877 {
 878     char * ret = virDomainGetOSType(domain);
 879     if (!ret) {
 880         virCopyLastError(err);
 881     }
 882     return ret;
 883 }
 884
 885
 886 int
 887 virDomainGetPerfEventsWrapper(virDomainPtr domain,
 888                               virTypedParameterPtr *params,
 889                               int *nparams,
 890                               unsigned int flags,
 891                               virErrorPtr err)
 892 {
 893 #if LIBVIR_VERSION_NUMBER < 1003003
 894     assert(0); // Caller should have checked version
 895 #else
 896     int ret = virDomainGetPerfEvents(domain, params, nparams, flags);
 897     if (ret < 0) {
 898         virCopyLastError(err);
 899     }
 900     return ret;
 901 #endif
 902 }
 903
 904
 905 int
 906 virDomainGetSchedulerParametersWrapper(virDomainPtr domain,
 907                                        virTypedParameterPtr params,
 908                                        int *nparams,
 909                                        virErrorPtr err)
 910 {
 911     int ret = virDomainGetSchedulerParameters(domain, params, nparams);
 912     if (ret < 0) {
 913         virCopyLastError(err);
 914     }
 915     return ret;
 916 }
 917
 918
 919 int
 920 virDomainGetSchedulerParametersFlagsWrapper(virDomainPtr domain,
 921                                             virTypedParameterPtr params,
 922                                             int *nparams,
 923                                             unsigned int flags,
 924                                             virErrorPtr err)
 925 {
 926     int ret = virDomainGetSchedulerParametersFlags(domain, params, nparams, flags);
 927     if (ret < 0) {
 928         virCopyLastError(err);
 929     }
 930     return ret;
 931 }
 932
 933
 934 char *
 935 virDomainGetSchedulerTypeWrapper(virDomainPtr domain,
 936                                  int *nparams,
 937                                  virErrorPtr err)
 938 {
 939     char * ret = virDomainGetSchedulerType(domain, nparams);
 940     if (!ret) {
 941         virCopyLastError(err);
 942     }
 943     return ret;
 944 }
 945
 946
 947 int
 948 virDomainGetSecurityLabelWrapper(virDomainPtr domain,
 949                                  virSecurityLabelPtr seclabel,
 950                                  virErrorPtr err)
 951 {
 952     int ret = virDomainGetSecurityLabel(domain, seclabel);
 953     if (ret < 0) {
 954         virCopyLastError(err);
 955     }
 956     return ret;
 957 }
 958
 959
 960 int
 961 virDomainGetSecurityLabelListWrapper(virDomainPtr domain,
 962                                      virSecurityLabelPtr *seclabels,
 963                                      virErrorPtr err)
 964 {
 965     int ret = virDomainGetSecurityLabelList(domain, seclabels);
 966     if (ret < 0) {
 967         virCopyLastError(err);
 968     }
 969     return ret;
 970 }
 971
 972
 973 int
 974 virDomainGetStateWrapper(virDomainPtr domain,
 975                          int *state,
 976                          int *reason,
 977                          unsigned int flags,
 978                          virErrorPtr err)
 979 {
 980     int ret = virDomainGetState(domain, state, reason, flags);
 981     if (ret < 0) {
 982         virCopyLastError(err);
 983     }
 984     return ret;
 985 }
 986
 987
 988 int
 989 virDomainGetTimeWrapper(virDomainPtr dom,
 990                         long long *seconds,
 991                         unsigned int *nseconds,
 992                         unsigned int flags,
 993                         virErrorPtr err)
 994 {
 995 #if LIBVIR_VERSION_NUMBER < 1002005
 996     assert(0); // Caller should have checked version
 997 #else
 998     int ret = virDomainGetTime(dom, seconds, nseconds, flags);
 999     if (ret < 0) {
1000         virCopyLastError(err);
1001     }
1002     return ret;
1003 #endif
1004 }
1005
1006
1007 int
1008 virDomainGetUUIDWrapper(virDomainPtr domain,
1009                         unsigned char *uuid,
1010                         virErrorPtr err)
1011 {
1012     int ret = virDomainGetUUID(domain, uuid);
1013     if (ret < 0) {
1014         virCopyLastError(err);
1015     }
1016     return ret;
1017 }
1018
1019
1020 int
1021 virDomainGetUUIDStringWrapper(virDomainPtr domain,
1022                               char *buf,
1023                               virErrorPtr err)
1024 {
1025     int ret = virDomainGetUUIDString(domain, buf);
1026     if (ret < 0) {
1027         virCopyLastError(err);
1028     }
1029     return ret;
1030 }
1031
1032
1033 int
1034 virDomainGetVcpuPinInfoWrapper(virDomainPtr domain,
1035                                int ncpumaps,
1036                                unsigned char *cpumaps,
1037                                int maplen,
1038                                unsigned int flags,
1039                                virErrorPtr err)
1040 {
1041     int ret = virDomainGetVcpuPinInfo(domain, ncpumaps, cpumaps, maplen, flags);
1042     if (ret < 0) {
1043         virCopyLastError(err);
1044     }
1045     return ret;
1046 }
1047
1048
1049 int
1050 virDomainGetVcpusWrapper(virDomainPtr domain,
1051                          virVcpuInfoPtr info,
1052                          int maxinfo,
1053                          unsigned char *cpumaps,
1054                          int maplen,
1055                          virErrorPtr err)
1056 {
1057     int ret = virDomainGetVcpus(domain, info, maxinfo, cpumaps, maplen);
1058     if (ret < 0) {
1059         virCopyLastError(err);
1060     }
1061     return ret;
1062 }
1063
1064
1065 int
1066 virDomainGetVcpusFlagsWrapper(virDomainPtr domain,
1067                               unsigned int flags,
1068                               virErrorPtr err)
1069 {
1070     int ret = virDomainGetVcpusFlags(domain, flags);
1071     if (ret < 0) {
1072         virCopyLastError(err);
1073     }
1074     return ret;
1075 }
1076
1077
1078 char *
1079 virDomainGetXMLDescWrapper(virDomainPtr domain,
1080                            unsigned int flags,
1081                            virErrorPtr err)
1082 {
1083     char * ret = virDomainGetXMLDesc(domain, flags);
1084     if (!ret) {
1085         virCopyLastError(err);
1086     }
1087     return ret;
1088 }
1089
1090
1091 int
1092 virDomainHasCurrentSnapshotWrapper(virDomainPtr domain,
1093                                    unsigned int flags,
1094                                    virErrorPtr err)
1095 {
1096     int ret = virDomainHasCurrentSnapshot(domain, flags);
1097     if (ret < 0) {
1098         virCopyLastError(err);
1099     }
1100     return ret;
1101 }
1102
1103
1104 int
1105 virDomainHasManagedSaveImageWrapper(virDomainPtr dom,
1106                                     unsigned int flags,
1107                                     virErrorPtr err)
1108 {
1109     int ret = virDomainHasManagedSaveImage(dom, flags);
1110     if (ret < 0) {
1111         virCopyLastError(err);
1112     }
1113     return ret;
1114 }
1115
1116
1117 int
1118 virDomainInjectNMIWrapper(virDomainPtr domain,
1119                           unsigned int flags,
1120                           virErrorPtr err)
1121 {
1122     int ret = virDomainInjectNMI(domain, flags);
1123     if (ret < 0) {
1124         virCopyLastError(err);
1125     }
1126     return ret;
1127 }
1128
1129
1130 int
1131 virDomainInterfaceAddressesWrapper(virDomainPtr dom,
1132                                    virDomainInterfacePtr **ifaces,
1133                                    unsigned int source,
1134                                    unsigned int flags,
1135                                    virErrorPtr err)
1136 {
1137 #if LIBVIR_VERSION_NUMBER < 1002014
1138     assert(0); // Caller should have checked version
1139 #else
1140     int ret = virDomainInterfaceAddresses(dom, ifaces, source, flags);
1141     if (ret < 0) {
1142         virCopyLastError(err);
1143     }
1144     return ret;
1145 #endif
1146 }
1147
1148
1149 void
1150 virDomainInterfaceFreeWrapper(virDomainInterfacePtr iface)
1151 {
1152 #if LIBVIR_VERSION_NUMBER < 1002014
1153     assert(0); // Caller should have checked version
1154 #else
1155     virDomainInterfaceFree(iface);
1156 #endif
1157 }
1158
1159
1160 int
1161 virDomainInterfaceStatsWrapper(virDomainPtr dom,
1162                                const char *device,
1163                                virDomainInterfaceStatsPtr stats,
1164                                size_t size,
1165                                virErrorPtr err)
1166 {
1167     int ret = virDomainInterfaceStats(dom, device, stats, size);
1168     if (ret < 0) {
1169         virCopyLastError(err);
1170     }
1171     return ret;
1172 }
1173
1174
1175 void
1176 virDomainIOThreadInfoFreeWrapper(virDomainIOThreadInfoPtr info)
1177 {
1178 #if LIBVIR_VERSION_NUMBER < 1002014
1179     assert(0); // Caller should have checked version
1180 #else
1181     virDomainIOThreadInfoFree(info);
1182 #endif
1183 }
1184
1185
1186 int
1187 virDomainIsActiveWrapper(virDomainPtr dom,
1188                          virErrorPtr err)
1189 {
1190     int ret = virDomainIsActive(dom);
1191     if (ret < 0) {
1192         virCopyLastError(err);
1193     }
1194     return ret;
1195 }
1196
1197
1198 int
1199 virDomainIsPersistentWrapper(virDomainPtr dom,
1200                              virErrorPtr err)
1201 {
1202     int ret = virDomainIsPersistent(dom);
1203     if (ret < 0) {
1204         virCopyLastError(err);
1205     }
1206     return ret;
1207 }
1208
1209
1210 int
1211 virDomainIsUpdatedWrapper(virDomainPtr dom,
1212                           virErrorPtr err)
1213 {
1214     int ret = virDomainIsUpdated(dom);
1215     if (ret < 0) {
1216         virCopyLastError(err);
1217     }
1218     return ret;
1219 }
1220
1221
1222 int
1223 virDomainListAllSnapshotsWrapper(virDomainPtr domain,
1224                                  virDomainSnapshotPtr **snaps,
1225                                  unsigned int flags,
1226                                  virErrorPtr err)
1227 {
1228     int ret = virDomainListAllSnapshots(domain, snaps, flags);
1229     if (ret < 0) {
1230         virCopyLastError(err);
1231     }
1232     return ret;
1233 }
1234
1235
1236 int
1237 virDomainManagedSaveWrapper(virDomainPtr dom,
1238                             unsigned int flags,
1239                             virErrorPtr err)
1240 {
1241     int ret = virDomainManagedSave(dom, flags);
1242     if (ret < 0) {
1243         virCopyLastError(err);
1244     }
1245     return ret;
1246 }
1247
1248
1249 int
1250 virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain,
1251                                      const char *dxml,
1252                                      unsigned int flags,
1253                                      virErrorPtr err)
1254 {
1255 #if LIBVIR_VERSION_NUMBER < 3007000
1256     assert(0); // Caller should have checked version
1257 #else
1258     int ret = virDomainManagedSaveDefineXML(domain, dxml, flags);
1259     if (ret < 0) {
1260         virCopyLastError(err);
1261     }
1262     return ret;
1263 #endif
1264 }
1265
1266
1267 char *
1268 virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain,
1269                                       unsigned int flags,
1270                                       virErrorPtr err)
1271 {
1272 #if LIBVIR_VERSION_NUMBER < 3007000
1273     assert(0); // Caller should have checked version
1274 #else
1275     char * ret = virDomainManagedSaveGetXMLDesc(domain, flags);
1276     if (!ret) {
1277         virCopyLastError(err);
1278     }
1279     return ret;
1280 #endif
1281 }
1282
1283
1284 int
1285 virDomainManagedSaveRemoveWrapper(virDomainPtr dom,
1286                                   unsigned int flags,
1287                                   virErrorPtr err)
1288 {
1289     int ret = virDomainManagedSaveRemove(dom, flags);
1290     if (ret < 0) {
1291         virCopyLastError(err);
1292     }
1293     return ret;
1294 }
1295
1296
1297 int
1298 virDomainMemoryPeekWrapper(virDomainPtr dom,
1299                            unsigned long long start,
1300                            size_t size,
1301                            void *buffer,
1302                            unsigned int flags,
1303                            virErrorPtr err)
1304 {
1305     int ret = virDomainMemoryPeek(dom, start, size, buffer, flags);
1306     if (ret < 0) {
1307         virCopyLastError(err);
1308     }
1309     return ret;
1310 }
1311
1312
1313 int
1314 virDomainMemoryStatsWrapper(virDomainPtr dom,
1315                             virDomainMemoryStatPtr stats,
1316                             unsigned int nr_stats,
1317                             unsigned int flags,
1318                             virErrorPtr err)
1319 {
1320     int ret = virDomainMemoryStats(dom, stats, nr_stats, flags);
1321     if (ret < 0) {
1322         virCopyLastError(err);
1323     }
1324     return ret;
1325 }
1326
1327
1328 virDomainPtr
1329 virDomainMigrateWrapper(virDomainPtr domain,
1330                         virConnectPtr dconn,
1331                         unsigned long flags,
1332                         const char *dname,
1333                         const char *uri,
1334                         unsigned long bandwidth,
1335                         virErrorPtr err)
1336 {
1337     virDomainPtr ret = virDomainMigrate(domain, dconn, flags, dname, uri, bandwidth);
1338     if (!ret) {
1339         virCopyLastError(err);
1340     }
1341     return ret;
1342 }
1343
1344
1345 virDomainPtr
1346 virDomainMigrate2Wrapper(virDomainPtr domain,
1347                          virConnectPtr dconn,
1348                          const char *dxml,
1349                          unsigned long flags,
1350                          const char *dname,
1351                          const char *uri,
1352                          unsigned long bandwidth,
1353                          virErrorPtr err)
1354 {
1355     virDomainPtr ret = virDomainMigrate2(domain, dconn, dxml, flags, dname, uri, bandwidth);
1356     if (!ret) {
1357         virCopyLastError(err);
1358     }
1359     return ret;
1360 }
1361
1362
1363 virDomainPtr
1364 virDomainMigrate3Wrapper(virDomainPtr domain,
1365                          virConnectPtr dconn,
1366                          virTypedParameterPtr params,
1367                          unsigned int nparams,
1368                          unsigned int flags,
1369                          virErrorPtr err)
1370 {
1371     virDomainPtr ret = virDomainMigrate3(domain, dconn, params, nparams, flags);
1372     if (!ret) {
1373         virCopyLastError(err);
1374     }
1375     return ret;
1376 }
1377
1378
1379 int
1380 virDomainMigrateGetCompressionCacheWrapper(virDomainPtr domain,
1381                                            unsigned long long *cacheSize,
1382                                            unsigned int flags,
1383                                            virErrorPtr err)
1384 {
1385     int ret = virDomainMigrateGetCompressionCache(domain, cacheSize, flags);
1386     if (ret < 0) {
1387         virCopyLastError(err);
1388     }
1389     return ret;
1390 }
1391
1392
1393 int
1394 virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain,
1395                                       unsigned long long *downtime,
1396                                       unsigned int flags,
1397                                       virErrorPtr err)
1398 {
1399 #if LIBVIR_VERSION_NUMBER < 3007000
1400     assert(0); // Caller should have checked version
1401 #else
1402     int ret = virDomainMigrateGetMaxDowntime(domain, downtime, flags);
1403     if (ret < 0) {
1404         virCopyLastError(err);
1405     }
1406     return ret;
1407 #endif
1408 }
1409
1410
1411 int
1412 virDomainMigrateGetMaxSpeedWrapper(virDomainPtr domain,
1413                                    unsigned long *bandwidth,
1414                                    unsigned int flags,
1415                                    virErrorPtr err)
1416 {
1417     int ret = virDomainMigrateGetMaxSpeed(domain, bandwidth, flags);
1418     if (ret < 0) {
1419         virCopyLastError(err);
1420     }
1421     return ret;
1422 }
1423
1424
1425 int
1426 virDomainMigrateSetCompressionCacheWrapper(virDomainPtr domain,
1427                                            unsigned long long cacheSize,
1428                                            unsigned int flags,
1429                                            virErrorPtr err)
1430 {
1431     int ret = virDomainMigrateSetCompressionCache(domain, cacheSize, flags);
1432     if (ret < 0) {
1433         virCopyLastError(err);
1434     }
1435     return ret;
1436 }
1437
1438
1439 int
1440 virDomainMigrateSetMaxDowntimeWrapper(virDomainPtr domain,
1441                                       unsigned long long downtime,
1442                                       unsigned int flags,
1443                                       virErrorPtr err)
1444 {
1445     int ret = virDomainMigrateSetMaxDowntime(domain, downtime, flags);
1446     if (ret < 0) {
1447         virCopyLastError(err);
1448     }
1449     return ret;
1450 }
1451
1452
1453 int
1454 virDomainMigrateSetMaxSpeedWrapper(virDomainPtr domain,
1455                                    unsigned long bandwidth,
1456                                    unsigned int flags,
1457                                    virErrorPtr err)
1458 {
1459     int ret = virDomainMigrateSetMaxSpeed(domain, bandwidth, flags);
1460     if (ret < 0) {
1461         virCopyLastError(err);
1462     }
1463     return ret;
1464 }
1465
1466
1467 int
1468 virDomainMigrateStartPostCopyWrapper(virDomainPtr domain,
1469                                      unsigned int flags,
1470                                      virErrorPtr err)
1471 {
1472 #if LIBVIR_VERSION_NUMBER < 1003003
1473     assert(0); // Caller should have checked version
1474 #else
1475     int ret = virDomainMigrateStartPostCopy(domain, flags);
1476     if (ret < 0) {
1477         virCopyLastError(err);
1478     }
1479     return ret;
1480 #endif
1481 }
1482
1483
1484 int
1485 virDomainMigrateToURIWrapper(virDomainPtr domain,
1486                              const char *duri,
1487                              unsigned long flags,
1488                              const char *dname,
1489                              unsigned long bandwidth,
1490                              virErrorPtr err)
1491 {
1492     int ret = virDomainMigrateToURI(domain, duri, flags, dname, bandwidth);
1493     if (ret < 0) {
1494         virCopyLastError(err);
1495     }
1496     return ret;
1497 }
1498
1499
1500 int
1501 virDomainMigrateToURI2Wrapper(virDomainPtr domain,
1502                               const char *dconnuri,
1503                               const char *miguri,
1504                               const char *dxml,
1505                               unsigned long flags,
1506                               const char *dname,
1507                               unsigned long bandwidth,
1508                               virErrorPtr err)
1509 {
1510     int ret = virDomainMigrateToURI2(domain, dconnuri, miguri, dxml, flags, dname, bandwidth);
1511     if (ret < 0) {
1512         virCopyLastError(err);
1513     }
1514     return ret;
1515 }
1516
1517
1518 int
1519 virDomainMigrateToURI3Wrapper(virDomainPtr domain,
1520                               const char *dconnuri,
1521                               virTypedParameterPtr params,
1522                               unsigned int nparams,
1523                               unsigned int flags,
1524                               virErrorPtr err)
1525 {
1526     int ret = virDomainMigrateToURI3(domain, dconnuri, params, nparams, flags);
1527     if (ret < 0) {
1528         virCopyLastError(err);
1529     }
1530     return ret;
1531 }
1532
1533
1534 int
1535 virDomainOpenChannelWrapper(virDomainPtr dom,
1536                             const char *name,
1537                             virStreamPtr st,
1538                             unsigned int flags,
1539                             virErrorPtr err)
1540 {
1541     int ret = virDomainOpenChannel(dom, name, st, flags);
1542     if (ret < 0) {
1543         virCopyLastError(err);
1544     }
1545     return ret;
1546 }
1547
1548
1549 int
1550 virDomainOpenConsoleWrapper(virDomainPtr dom,
1551                             const char *dev_name,
1552                             virStreamPtr st,
1553                             unsigned int flags,
1554                             virErrorPtr err)
1555 {
1556     int ret = virDomainOpenConsole(dom, dev_name, st, flags);
1557     if (ret < 0) {
1558         virCopyLastError(err);
1559     }
1560     return ret;
1561 }
1562
1563
1564 int
1565 virDomainOpenGraphicsWrapper(virDomainPtr dom,
1566                              unsigned int idx,
1567                              int fd,
1568                              unsigned int flags,
1569                              virErrorPtr err)
1570 {
1571     int ret = virDomainOpenGraphics(dom, idx, fd, flags);
1572     if (ret < 0) {
1573         virCopyLastError(err);
1574     }
1575     return ret;
1576 }
1577
1578
1579 int
1580 virDomainOpenGraphicsFDWrapper(virDomainPtr dom,
1581                                unsigned int idx,
1582                                unsigned int flags,
1583                                virErrorPtr err)
1584 {
1585 #if LIBVIR_VERSION_NUMBER < 1002008
1586     assert(0); // Caller should have checked version
1587 #else
1588     int ret = virDomainOpenGraphicsFD(dom, idx, flags);
1589     if (ret < 0) {
1590         virCopyLastError(err);
1591     }
1592     return ret;
1593 #endif
1594 }
1595
1596
1597 int
1598 virDomainPMSuspendForDurationWrapper(virDomainPtr dom,
1599                                      unsigned int target,
1600                                      unsigned long long duration,
1601                                      unsigned int flags,
1602                                      virErrorPtr err)
1603 {
1604     int ret = virDomainPMSuspendForDuration(dom, target, duration, flags);
1605     if (ret < 0) {
1606         virCopyLastError(err);
1607     }
1608     return ret;
1609 }
1610
1611
1612 int
1613 virDomainPMWakeupWrapper(virDomainPtr dom,
1614                          unsigned int flags,
1615                          virErrorPtr err)
1616 {
1617     int ret = virDomainPMWakeup(dom, flags);
1618     if (ret < 0) {
1619         virCopyLastError(err);
1620     }
1621     return ret;
1622 }
1623
1624
1625 int
1626 virDomainPinEmulatorWrapper(virDomainPtr domain,
1627                             unsigned char *cpumap,
1628                             int maplen,
1629                             unsigned int flags,
1630                             virErrorPtr err)
1631 {
1632     int ret = virDomainPinEmulator(domain, cpumap, maplen, flags);
1633     if (ret < 0) {
1634         virCopyLastError(err);
1635     }
1636     return ret;
1637 }
1638
1639
1640 int
1641 virDomainPinIOThreadWrapper(virDomainPtr domain,
1642                             unsigned int iothread_id,
1643                             unsigned char *cpumap,
1644                             int maplen,
1645                             unsigned int flags,
1646                             virErrorPtr err)
1647 {
1648 #if LIBVIR_VERSION_NUMBER < 1002014
1649     assert(0); // Caller should have checked version
1650 #else
1651     int ret = virDomainPinIOThread(domain, iothread_id, cpumap, maplen, flags);
1652     if (ret < 0) {
1653         virCopyLastError(err);
1654     }
1655     return ret;
1656 #endif
1657 }
1658
1659
1660 int
1661 virDomainPinVcpuWrapper(virDomainPtr domain,
1662                         unsigned int vcpu,
1663                         unsigned char *cpumap,
1664                         int maplen,
1665                         virErrorPtr err)
1666 {
1667     int ret = virDomainPinVcpu(domain, vcpu, cpumap, maplen);
1668     if (ret < 0) {
1669         virCopyLastError(err);
1670     }
1671     return ret;
1672 }
1673
1674
1675 int
1676 virDomainPinVcpuFlagsWrapper(virDomainPtr domain,
1677                              unsigned int vcpu,
1678                              unsigned char *cpumap,
1679                              int maplen,
1680                              unsigned int flags,
1681                              virErrorPtr err)
1682 {
1683     int ret = virDomainPinVcpuFlags(domain, vcpu, cpumap, maplen, flags);
1684     if (ret < 0) {
1685         virCopyLastError(err);
1686     }
1687     return ret;
1688 }
1689
1690
1691 int
1692 virDomainRebootWrapper(virDomainPtr domain,
1693                        unsigned int flags,
1694                        virErrorPtr err)
1695 {
1696     int ret = virDomainReboot(domain, flags);
1697     if (ret < 0) {
1698         virCopyLastError(err);
1699     }
1700     return ret;
1701 }
1702
1703
1704 int
1705 virDomainRefWrapper(virDomainPtr domain,
1706                     virErrorPtr err)
1707 {
1708     int ret = virDomainRef(domain);
1709     if (ret < 0) {
1710         virCopyLastError(err);
1711     }
1712     return ret;
1713 }
1714
1715
1716 int
1717 virDomainRenameWrapper(virDomainPtr dom,
1718                        const char *new_name,
1719                        unsigned int flags,
1720                        virErrorPtr err)
1721 {
1722 #if LIBVIR_VERSION_NUMBER < 1002019
1723     assert(0); // Caller should have checked version
1724 #else
1725     int ret = virDomainRename(dom, new_name, flags);
1726     if (ret < 0) {
1727         virCopyLastError(err);
1728     }
1729     return ret;
1730 #endif
1731 }
1732
1733
1734 int
1735 virDomainResetWrapper(virDomainPtr domain,
1736                       unsigned int flags,
1737                       virErrorPtr err)
1738 {
1739     int ret = virDomainReset(domain, flags);
1740     if (ret < 0) {
1741         virCopyLastError(err);
1742     }
1743     return ret;
1744 }
1745
1746
1747 int
1748 virDomainResumeWrapper(virDomainPtr domain,
1749                        virErrorPtr err)
1750 {
1751     int ret = virDomainResume(domain);
1752     if (ret < 0) {
1753         virCopyLastError(err);
1754     }
1755     return ret;
1756 }
1757
1758
1759 int
1760 virDomainSaveWrapper(virDomainPtr domain,
1761                      const char *to,
1762                      virErrorPtr err)
1763 {
1764     int ret = virDomainSave(domain, to);
1765     if (ret < 0) {
1766         virCopyLastError(err);
1767     }
1768     return ret;
1769 }
1770
1771
1772 int
1773 virDomainSaveFlagsWrapper(virDomainPtr domain,
1774                           const char *to,
1775                           const char *dxml,
1776                           unsigned int flags,
1777                           virErrorPtr err)
1778 {
1779     int ret = virDomainSaveFlags(domain, to, dxml, flags);
1780     if (ret < 0) {
1781         virCopyLastError(err);
1782     }
1783     return ret;
1784 }
1785
1786
1787 char *
1788 virDomainScreenshotWrapper(virDomainPtr domain,
1789                            virStreamPtr stream,
1790                            unsigned int screen,
1791                            unsigned int flags,
1792                            virErrorPtr err)
1793 {
1794     char * ret = virDomainScreenshot(domain, stream, screen, flags);
1795     if (!ret) {
1796         virCopyLastError(err);
1797     }
1798     return ret;
1799 }
1800
1801
1802 int
1803 virDomainSendKeyWrapper(virDomainPtr domain,
1804                         unsigned int codeset,
1805                         unsigned int holdtime,
1806                         unsigned int *keycodes,
1807                         int nkeycodes,
1808                         unsigned int flags,
1809                         virErrorPtr err)
1810 {
1811     int ret = virDomainSendKey(domain, codeset, holdtime, keycodes, nkeycodes, flags);
1812     if (ret < 0) {
1813         virCopyLastError(err);
1814     }
1815     return ret;
1816 }
1817
1818
1819 int
1820 virDomainSendProcessSignalWrapper(virDomainPtr domain,
1821                                   long long pid_value,
1822                                   unsigned int signum,
1823                                   unsigned int flags,
1824                                   virErrorPtr err)
1825 {
1826     int ret = virDomainSendProcessSignal(domain, pid_value, signum, flags);
1827     if (ret < 0) {
1828         virCopyLastError(err);
1829     }
1830     return ret;
1831 }
1832
1833
1834 int
1835 virDomainSetAutostartWrapper(virDomainPtr domain,
1836                              int autostart,
1837                              virErrorPtr err)
1838 {
1839     int ret = virDomainSetAutostart(domain, autostart);
1840     if (ret < 0) {
1841         virCopyLastError(err);
1842     }
1843     return ret;
1844 }
1845
1846
1847 int
1848 virDomainSetBlkioParametersWrapper(virDomainPtr domain,
1849                                    virTypedParameterPtr params,
1850                                    int nparams,
1851                                    unsigned int flags,
1852                                    virErrorPtr err)
1853 {
1854     int ret = virDomainSetBlkioParameters(domain, params, nparams, flags);
1855     if (ret < 0) {
1856         virCopyLastError(err);
1857     }
1858     return ret;
1859 }
1860
1861
1862 int
1863 virDomainSetBlockIoTuneWrapper(virDomainPtr dom,
1864                                const char *disk,
1865                                virTypedParameterPtr params,
1866                                int nparams,
1867                                unsigned int flags,
1868                                virErrorPtr err)
1869 {
1870     int ret = virDomainSetBlockIoTune(dom, disk, params, nparams, flags);
1871     if (ret < 0) {
1872         virCopyLastError(err);
1873     }
1874     return ret;
1875 }
1876
1877
1878 int
1879 virDomainSetBlockThresholdWrapper(virDomainPtr domain,
1880                                   const char *dev,
1881                                   unsigned long long threshold,
1882                                   unsigned int flags,
1883                                   virErrorPtr err)
1884 {
1885 #if LIBVIR_VERSION_NUMBER < 3002000
1886     assert(0); // Caller should have checked version
1887 #else
1888     int ret = virDomainSetBlockThreshold(domain, dev, threshold, flags);
1889     if (ret < 0) {
1890         virCopyLastError(err);
1891     }
1892     return ret;
1893 #endif
1894 }
1895
1896
1897 int
1898 virDomainSetGuestVcpusWrapper(virDomainPtr domain,
1899                               const char *cpumap,
1900                               int state,
1901                               unsigned int flags,
1902                               virErrorPtr err)
1903 {
1904 #if LIBVIR_VERSION_NUMBER < 2000000
1905     assert(0); // Caller should have checked version
1906 #else
1907     int ret = virDomainSetGuestVcpus(domain, cpumap, state, flags);
1908     if (ret < 0) {
1909         virCopyLastError(err);
1910     }
1911     return ret;
1912 #endif
1913 }
1914
1915
1916 int
1917 virDomainSetInterfaceParametersWrapper(virDomainPtr domain,
1918                                        const char *device,
1919                                        virTypedParameterPtr params,
1920                                        int nparams,
1921                                        unsigned int flags,
1922                                        virErrorPtr err)
1923 {
1924     int ret = virDomainSetInterfaceParameters(domain, device, params, nparams, flags);
1925     if (ret < 0) {
1926         virCopyLastError(err);
1927     }
1928     return ret;
1929 }
1930
1931
1932 int
1933 virDomainSetLifecycleActionWrapper(virDomainPtr domain,
1934                                    unsigned int type,
1935                                    unsigned int action,
1936                                    unsigned int flags,
1937                                    virErrorPtr err)
1938 {
1939 #if LIBVIR_VERSION_NUMBER < 3009000
1940     assert(0); // Caller should have checked version
1941 #else
1942     int ret = virDomainSetLifecycleAction(domain, type, action, flags);
1943     if (ret < 0) {
1944         virCopyLastError(err);
1945     }
1946     return ret;
1947 #endif
1948 }
1949
1950
1951 int
1952 virDomainSetMaxMemoryWrapper(virDomainPtr domain,
1953                              unsigned long memory,
1954                              virErrorPtr err)
1955 {
1956     int ret = virDomainSetMaxMemory(domain, memory);
1957     if (ret < 0) {
1958         virCopyLastError(err);
1959     }
1960     return ret;
1961 }
1962
1963
1964 int
1965 virDomainSetMemoryWrapper(virDomainPtr domain,
1966                           unsigned long memory,
1967                           virErrorPtr err)
1968 {
1969     int ret = virDomainSetMemory(domain, memory);
1970     if (ret < 0) {
1971         virCopyLastError(err);
1972     }
1973     return ret;
1974 }
1975
1976
1977 int
1978 virDomainSetMemoryFlagsWrapper(virDomainPtr domain,
1979                                unsigned long memory,
1980                                unsigned int flags,
1981                                virErrorPtr err)
1982 {
1983     int ret = virDomainSetMemoryFlags(domain, memory, flags);
1984     if (ret < 0) {
1985         virCopyLastError(err);
1986     }
1987     return ret;
1988 }
1989
1990
1991 int
1992 virDomainSetMemoryParametersWrapper(virDomainPtr domain,
1993                                     virTypedParameterPtr params,
1994                                     int nparams,
1995                                     unsigned int flags,
1996                                     virErrorPtr err)
1997 {
1998     int ret = virDomainSetMemoryParameters(domain, params, nparams, flags);
1999     if (ret < 0) {
2000         virCopyLastError(err);
2001     }
2002     return ret;
2003 }
2004
2005
2006 int
2007 virDomainSetMemoryStatsPeriodWrapper(virDomainPtr domain,
2008                                      int period,
2009                                      unsigned int flags,
2010                                      virErrorPtr err)
2011 {
2012     int ret = virDomainSetMemoryStatsPeriod(domain, period, flags);
2013     if (ret < 0) {
2014         virCopyLastError(err);
2015     }
2016     return ret;
2017 }
2018
2019
2020 int
2021 virDomainSetMetadataWrapper(virDomainPtr domain,
2022                             int type,
2023                             const char *metadata,
2024                             const char *key,
2025                             const char *uri,
2026                             unsigned int flags,
2027                             virErrorPtr err)
2028 {
2029     int ret = virDomainSetMetadata(domain, type, metadata, key, uri, flags);
2030     if (ret < 0) {
2031         virCopyLastError(err);
2032     }
2033     return ret;
2034 }
2035
2036
2037 int
2038 virDomainSetNumaParametersWrapper(virDomainPtr domain,
2039                                   virTypedParameterPtr params,
2040                                   int nparams,
2041                                   unsigned int flags,
2042                                   virErrorPtr err)
2043 {
2044     int ret = virDomainSetNumaParameters(domain, params, nparams, flags);
2045     if (ret < 0) {
2046         virCopyLastError(err);
2047     }
2048     return ret;
2049 }
2050
2051
2052 int
2053 virDomainSetPerfEventsWrapper(virDomainPtr domain,
2054                               virTypedParameterPtr params,
2055                               int nparams,
2056                               unsigned int flags,
2057                               virErrorPtr err)
2058 {
2059 #if LIBVIR_VERSION_NUMBER < 1003003
2060     assert(0); // Caller should have checked version
2061 #else
2062     int ret = virDomainSetPerfEvents(domain, params, nparams, flags);
2063     if (ret < 0) {
2064         virCopyLastError(err);
2065     }
2066     return ret;
2067 #endif
2068 }
2069
2070
2071 int
2072 virDomainSetSchedulerParametersWrapper(virDomainPtr domain,
2073                                        virTypedParameterPtr params,
2074                                        int nparams,
2075                                        virErrorPtr err)
2076 {
2077     int ret = virDomainSetSchedulerParameters(domain, params, nparams);
2078     if (ret < 0) {
2079         virCopyLastError(err);
2080     }
2081     return ret;
2082 }
2083
2084
2085 int
2086 virDomainSetSchedulerParametersFlagsWrapper(virDomainPtr domain,
2087                                             virTypedParameterPtr params,
2088                                             int nparams,
2089                                             unsigned int flags,
2090                                             virErrorPtr err)
2091 {
2092     int ret = virDomainSetSchedulerParametersFlags(domain, params, nparams, flags);
2093     if (ret < 0) {
2094         virCopyLastError(err);
2095     }
2096     return ret;
2097 }
2098
2099
2100 int
2101 virDomainSetTimeWrapper(virDomainPtr dom,
2102                         long long seconds,
2103                         unsigned int nseconds,
2104                         unsigned int flags,
2105                         virErrorPtr err)
2106 {
2107 #if LIBVIR_VERSION_NUMBER < 1002005
2108     assert(0); // Caller should have checked version
2109 #else
2110     int ret = virDomainSetTime(dom, seconds, nseconds, flags);
2111     if (ret < 0) {
2112         virCopyLastError(err);
2113     }
2114     return ret;
2115 #endif
2116 }
2117
2118
2119 int
2120 virDomainSetUserPasswordWrapper(virDomainPtr dom,
2121                                 const char *user,
2122                                 const char *password,
2123                                 unsigned int flags,
2124                                 virErrorPtr err)
2125 {
2126 #if LIBVIR_VERSION_NUMBER < 1002016
2127     assert(0); // Caller should have checked version
2128 #else
2129     int ret = virDomainSetUserPassword(dom, user, password, flags);
2130     if (ret < 0) {
2131         virCopyLastError(err);
2132     }
2133     return ret;
2134 #endif
2135 }
2136
2137
2138 int
2139 virDomainSetVcpuWrapper(virDomainPtr domain,
2140                         const char *vcpumap,
2141                         int state,
2142                         unsigned int flags,
2143                         virErrorPtr err)
2144 {
2145 #if LIBVIR_VERSION_NUMBER < 3001000
2146     assert(0); // Caller should have checked version
2147 #else
2148     int ret = virDomainSetVcpu(domain, vcpumap, state, flags);
2149     if (ret < 0) {
2150         virCopyLastError(err);
2151     }
2152     return ret;
2153 #endif
2154 }
2155
2156
2157 int
2158 virDomainSetVcpusWrapper(virDomainPtr domain,
2159                          unsigned int nvcpus,
2160                          virErrorPtr err)
2161 {
2162     int ret = virDomainSetVcpus(domain, nvcpus);
2163     if (ret < 0) {
2164         virCopyLastError(err);
2165     }
2166     return ret;
2167 }
2168
2169
2170 int
2171 virDomainSetVcpusFlagsWrapper(virDomainPtr domain,
2172                               unsigned int nvcpus,
2173                               unsigned int flags,
2174                               virErrorPtr err)
2175 {
2176     int ret = virDomainSetVcpusFlags(domain, nvcpus, flags);
2177     if (ret < 0) {
2178         virCopyLastError(err);
2179     }
2180     return ret;
2181 }
2182
2183
2184 int
2185 virDomainShutdownWrapper(virDomainPtr domain,
2186                          virErrorPtr err)
2187 {
2188     int ret = virDomainShutdown(domain);
2189     if (ret < 0) {
2190         virCopyLastError(err);
2191     }
2192     return ret;
2193 }
2194
2195
2196 int
2197 virDomainShutdownFlagsWrapper(virDomainPtr domain,
2198                               unsigned int flags,
2199                               virErrorPtr err)
2200 {
2201     int ret = virDomainShutdownFlags(domain, flags);
2202     if (ret < 0) {
2203         virCopyLastError(err);
2204     }
2205     return ret;
2206 }
2207
2208
2209 virDomainSnapshotPtr
2210 virDomainSnapshotCreateXMLWrapper(virDomainPtr domain,
2211                                   const char *xmlDesc,
2212                                   unsigned int flags,
2213                                   virErrorPtr err)
2214 {
2215     virDomainSnapshotPtr ret = virDomainSnapshotCreateXML(domain, xmlDesc, flags);
2216     if (!ret) {
2217         virCopyLastError(err);
2218     }
2219     return ret;
2220 }
2221
2222
2223 virDomainSnapshotPtr
2224 virDomainSnapshotCurrentWrapper(virDomainPtr domain,
2225                                 unsigned int flags,
2226                                 virErrorPtr err)
2227 {
2228     virDomainSnapshotPtr ret = virDomainSnapshotCurrent(domain, flags);
2229     if (!ret) {
2230         virCopyLastError(err);
2231     }
2232     return ret;
2233 }
2234
2235
2236 int
2237 virDomainSnapshotListNamesWrapper(virDomainPtr domain,
2238                                   char **names,
2239                                   int nameslen,
2240                                   unsigned int flags,
2241                                   virErrorPtr err)
2242 {
2243     int ret = virDomainSnapshotListNames(domain, names, nameslen, flags);
2244     if (ret < 0) {
2245         virCopyLastError(err);
2246     }
2247     return ret;
2248 }
2249
2250
2251 virDomainSnapshotPtr
2252 virDomainSnapshotLookupByNameWrapper(virDomainPtr domain,
2253                                      const char *name,
2254                                      unsigned int flags,
2255                                      virErrorPtr err)
2256 {
2257     virDomainSnapshotPtr ret = virDomainSnapshotLookupByName(domain, name, flags);
2258     if (!ret) {
2259         virCopyLastError(err);
2260     }
2261     return ret;
2262 }
2263
2264
2265 int
2266 virDomainSnapshotNumWrapper(virDomainPtr domain,
2267                             unsigned int flags,
2268                             virErrorPtr err)
2269 {
2270     int ret = virDomainSnapshotNum(domain, flags);
2271     if (ret < 0) {
2272         virCopyLastError(err);
2273     }
2274     return ret;
2275 }
2276
2277
2278 int
2279 virDomainSuspendWrapper(virDomainPtr domain,
2280                         virErrorPtr err)
2281 {
2282     int ret = virDomainSuspend(domain);
2283     if (ret < 0) {
2284         virCopyLastError(err);
2285     }
2286     return ret;
2287 }
2288
2289
2290 int
2291 virDomainUndefineWrapper(virDomainPtr domain,
2292                          virErrorPtr err)
2293 {
2294     int ret = virDomainUndefine(domain);
2295     if (ret < 0) {
2296         virCopyLastError(err);
2297     }
2298     return ret;
2299 }
2300
2301
2302 int
2303 virDomainUndefineFlagsWrapper(virDomainPtr domain,
2304                               unsigned int flags,
2305                               virErrorPtr err)
2306 {
2307     int ret = virDomainUndefineFlags(domain, flags);
2308     if (ret < 0) {
2309         virCopyLastError(err);
2310     }
2311     return ret;
2312 }
2313
2314
2315 int
2316 virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain,
2317                                   const char *xml,
2318                                   unsigned int flags,
2319                                   virErrorPtr err)
2320 {
2321     int ret = virDomainUpdateDeviceFlags(domain, xml, flags);
2322     if (ret < 0) {
2323         virCopyLastError(err);
2324     }
2325     return ret;
2326 }
2327
2328
2329 */
2330 import "C"