src/dma/vendor/github.com/libvirt/libvirt-go/connect_wrapper.h

   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 #ifndef LIBVIRT_GO_CONNECT_WRAPPER_H__
  28 #define LIBVIRT_GO_CONNECT_WRAPPER_H__
  29
  30 #include <libvirt/libvirt.h>
  31 #include <libvirt/virterror.h>
  32 #include "connect_compat.h"
  33
  34 void
  35 closeCallbackHelper(virConnectPtr conn,
  36                     int reason,
  37                     void *opaque);
  38
  39 int
  40 virConnectRegisterCloseCallbackHelper(virConnectPtr c,
  41                                       virConnectCloseFunc cb,
  42                                       long goCallbackId);
  43
  44 char *
  45 virConnectBaselineCPUWrapper(virConnectPtr conn,
  46                              const char **xmlCPUs,
  47                              unsigned int ncpus,
  48                              unsigned int flags,
  49                              virErrorPtr err);
  50
  51 char *
  52 virConnectBaselineHypervisorCPUWrapper(virConnectPtr conn,
  53                                        const char *emulator,
  54                                        const char *arch,
  55                                        const char *machine,
  56                                        const char *virttype,
  57                                        const char **xmlCPUs,
  58                                        unsigned int ncpus,
  59                                        unsigned int flags,
  60                                        virErrorPtr err);
  61
  62 int
  63 virConnectCloseWrapper(virConnectPtr conn,
  64                        virErrorPtr err);
  65
  66 int
  67 virConnectCompareCPUWrapper(virConnectPtr conn,
  68                             const char *xmlDesc,
  69                             unsigned int flags,
  70                             virErrorPtr err);
  71
  72 int
  73 virConnectCompareHypervisorCPUWrapper(virConnectPtr conn,
  74                                       const char *emulator,
  75                                       const char *arch,
  76                                       const char *machine,
  77                                       const char *virttype,
  78                                       const char *xmlCPU,
  79                                       unsigned int flags,
  80                                       virErrorPtr err);
  81
  82 char *
  83 virConnectDomainXMLFromNativeWrapper(virConnectPtr conn,
  84                                      const char *nativeFormat,
  85                                      const char *nativeConfig,
  86                                      unsigned int flags,
  87                                      virErrorPtr err);
  88
  89 char *
  90 virConnectDomainXMLToNativeWrapper(virConnectPtr conn,
  91                                    const char *nativeFormat,
  92                                    const char *domainXml,
  93                                    unsigned int flags,
  94                                    virErrorPtr err);
  95
  96 char *
  97 virConnectFindStoragePoolSourcesWrapper(virConnectPtr conn,
  98                                         const char *type,
  99                                         const char *srcSpec,
 100                                         unsigned int flags,
 101                                         virErrorPtr err);
 102
 103 int
 104 virConnectGetAllDomainStatsWrapper(virConnectPtr conn,
 105                                    unsigned int stats,
 106                                    virDomainStatsRecordPtr **retStats,
 107                                    unsigned int flags,
 108                                    virErrorPtr err);
 109
 110 int
 111 virConnectGetCPUModelNamesWrapper(virConnectPtr conn,
 112                                   const char *arch,
 113                                   char ***models,
 114                                   unsigned int flags,
 115                                   virErrorPtr err);
 116
 117 char *
 118 virConnectGetCapabilitiesWrapper(virConnectPtr conn,
 119                                  virErrorPtr err);
 120
 121 char *
 122 virConnectGetDomainCapabilitiesWrapper(virConnectPtr conn,
 123                                        const char *emulatorbin,
 124                                        const char *arch,
 125                                        const char *machine,
 126                                        const char *virttype,
 127                                        unsigned int flags,
 128                                        virErrorPtr err);
 129
 130 char *
 131 virConnectGetHostnameWrapper(virConnectPtr conn,
 132                              virErrorPtr err);
 133
 134 int
 135 virConnectGetLibVersionWrapper(virConnectPtr conn,
 136                                unsigned long *libVer,
 137                                virErrorPtr err);
 138
 139 int
 140 virConnectGetMaxVcpusWrapper(virConnectPtr conn,
 141                              const char *type,
 142                              virErrorPtr err);
 143
 144 char *
 145 virConnectGetSysinfoWrapper(virConnectPtr conn,
 146                             unsigned int flags,
 147                             virErrorPtr err);
 148
 149 const char *
 150 virConnectGetTypeWrapper(virConnectPtr conn,
 151                          virErrorPtr err);
 152
 153 char *
 154 virConnectGetURIWrapper(virConnectPtr conn,
 155                         virErrorPtr err);
 156
 157 int
 158 virConnectGetVersionWrapper(virConnectPtr conn,
 159                             unsigned long *hvVer,
 160                             virErrorPtr err);
 161
 162 int
 163 virConnectIsAliveWrapper(virConnectPtr conn,
 164                          virErrorPtr err);
 165
 166 int
 167 virConnectIsEncryptedWrapper(virConnectPtr conn,
 168                              virErrorPtr err);
 169
 170 int
 171 virConnectIsSecureWrapper(virConnectPtr conn,
 172                           virErrorPtr err);
 173
 174 int
 175 virConnectListAllDomainsWrapper(virConnectPtr conn,
 176                                 virDomainPtr **domains,
 177                                 unsigned int flags,
 178                                 virErrorPtr err);
 179
 180 int
 181 virConnectListAllInterfacesWrapper(virConnectPtr conn,
 182                                    virInterfacePtr **ifaces,
 183                                    unsigned int flags,
 184                                    virErrorPtr err);
 185
 186 int
 187 virConnectListAllNWFilterBindingsWrapper(virConnectPtr conn,
 188                                          virNWFilterBindingPtr **bindings,
 189                                          unsigned int flags,
 190                                          virErrorPtr err);
 191
 192 int
 193 virConnectListAllNWFiltersWrapper(virConnectPtr conn,
 194                                   virNWFilterPtr **filters,
 195                                   unsigned int flags,
 196                                   virErrorPtr err);
 197
 198 int
 199 virConnectListAllNetworksWrapper(virConnectPtr conn,
 200                                  virNetworkPtr **nets,
 201                                  unsigned int flags,
 202                                  virErrorPtr err);
 203
 204 int
 205 virConnectListAllNodeDevicesWrapper(virConnectPtr conn,
 206                                     virNodeDevicePtr **devices,
 207                                     unsigned int flags,
 208                                     virErrorPtr err);
 209
 210 int
 211 virConnectListAllSecretsWrapper(virConnectPtr conn,
 212                                 virSecretPtr **secrets,
 213                                 unsigned int flags,
 214                                 virErrorPtr err);
 215
 216 int
 217 virConnectListAllStoragePoolsWrapper(virConnectPtr conn,
 218                                      virStoragePoolPtr **pools,
 219                                      unsigned int flags,
 220                                      virErrorPtr err);
 221
 222 int
 223 virConnectListDefinedDomainsWrapper(virConnectPtr conn,
 224                                     char **const names,
 225                                     int maxnames,
 226                                     virErrorPtr err);
 227
 228 int
 229 virConnectListDefinedInterfacesWrapper(virConnectPtr conn,
 230                                        char **const names,
 231                                        int maxnames,
 232                                        virErrorPtr err);
 233
 234 int
 235 virConnectListDefinedNetworksWrapper(virConnectPtr conn,
 236                                      char **const names,
 237                                      int maxnames,
 238                                      virErrorPtr err);
 239
 240 int
 241 virConnectListDefinedStoragePoolsWrapper(virConnectPtr conn,
 242                                          char **const names,
 243                                          int maxnames,
 244                                          virErrorPtr err);
 245
 246 int
 247 virConnectListDomainsWrapper(virConnectPtr conn,
 248                              int *ids,
 249                              int maxids,
 250                              virErrorPtr err);
 251
 252 int
 253 virConnectListInterfacesWrapper(virConnectPtr conn,
 254                                 char **const names,
 255                                 int maxnames,
 256                                 virErrorPtr err);
 257
 258 int
 259 virConnectListNWFiltersWrapper(virConnectPtr conn,
 260                                char **const names,
 261                                int maxnames,
 262                                virErrorPtr err);
 263
 264 int
 265 virConnectListNetworksWrapper(virConnectPtr conn,
 266                               char **const names,
 267                               int maxnames,
 268                               virErrorPtr err);
 269
 270 int
 271 virConnectListSecretsWrapper(virConnectPtr conn,
 272                              char **uuids,
 273                              int maxuuids,
 274                              virErrorPtr err);
 275
 276 int
 277 virConnectListStoragePoolsWrapper(virConnectPtr conn,
 278                                   char **const names,
 279                                   int maxnames,
 280                                   virErrorPtr err);
 281
 282 int
 283 virConnectNumOfDefinedDomainsWrapper(virConnectPtr conn,
 284                                      virErrorPtr err);
 285
 286 int
 287 virConnectNumOfDefinedInterfacesWrapper(virConnectPtr conn,
 288                                         virErrorPtr err);
 289
 290 int
 291 virConnectNumOfDefinedNetworksWrapper(virConnectPtr conn,
 292                                       virErrorPtr err);
 293
 294 int
 295 virConnectNumOfDefinedStoragePoolsWrapper(virConnectPtr conn,
 296                                           virErrorPtr err);
 297
 298 int
 299 virConnectNumOfDomainsWrapper(virConnectPtr conn,
 300                               virErrorPtr err);
 301
 302 int
 303 virConnectNumOfInterfacesWrapper(virConnectPtr conn,
 304                                  virErrorPtr err);
 305
 306 int
 307 virConnectNumOfNWFiltersWrapper(virConnectPtr conn,
 308                                 virErrorPtr err);
 309
 310 int
 311 virConnectNumOfNetworksWrapper(virConnectPtr conn,
 312                                virErrorPtr err);
 313
 314 int
 315 virConnectNumOfSecretsWrapper(virConnectPtr conn,
 316                               virErrorPtr err);
 317
 318 int
 319 virConnectNumOfStoragePoolsWrapper(virConnectPtr conn,
 320                                    virErrorPtr err);
 321
 322 virConnectPtr
 323 virConnectOpenWrapper(const char *name,
 324                       virErrorPtr err);
 325
 326 virConnectPtr
 327 virConnectOpenAuthWrapper(const char *name,
 328                           int *credtype,
 329                           unsigned int ncredtype,
 330                           int callbackID,
 331                           unsigned int flags,
 332                           virErrorPtr err);
 333
 334 virConnectPtr
 335 virConnectOpenReadOnlyWrapper(const char *name,
 336                               virErrorPtr err);
 337
 338 int
 339 virConnectRefWrapper(virConnectPtr conn,
 340                      virErrorPtr err);
 341
 342 int
 343 virConnectRegisterCloseCallbackWrapper(virConnectPtr conn,
 344                                        long goCallbackId,
 345                                        virErrorPtr err);
 346
 347 int
 348 virConnectSetKeepAliveWrapper(virConnectPtr conn,
 349                               int interval,
 350                               unsigned int count,
 351                               virErrorPtr err);
 352
 353 int
 354 virConnectUnregisterCloseCallbackWrapper(virConnectPtr conn,
 355                                          virErrorPtr err);
 356
 357 virDomainPtr
 358 virDomainCreateLinuxWrapper(virConnectPtr conn,
 359                             const char *xmlDesc,
 360                             unsigned int flags,
 361                             virErrorPtr err);
 362
 363 virDomainPtr
 364 virDomainCreateXMLWrapper(virConnectPtr conn,
 365                           const char *xmlDesc,
 366                           unsigned int flags,
 367                           virErrorPtr err);
 368
 369 virDomainPtr
 370 virDomainCreateXMLWithFilesWrapper(virConnectPtr conn,
 371                                    const char *xmlDesc,
 372                                    unsigned int nfiles,
 373                                    int *files,
 374                                    unsigned int flags,
 375                                    virErrorPtr err);
 376
 377 virDomainPtr
 378 virDomainDefineXMLWrapper(virConnectPtr conn,
 379                           const char *xml,
 380                           virErrorPtr err);
 381
 382 virDomainPtr
 383 virDomainDefineXMLFlagsWrapper(virConnectPtr conn,
 384                                const char *xml,
 385                                unsigned int flags,
 386                                virErrorPtr err);
 387
 388 int
 389 virDomainListGetStatsWrapper(virDomainPtr *doms,
 390                              unsigned int stats,
 391                              virDomainStatsRecordPtr **retStats,
 392                              unsigned int flags,
 393                              virErrorPtr err);
 394
 395 virDomainPtr
 396 virDomainLookupByIDWrapper(virConnectPtr conn,
 397                            int id,
 398                            virErrorPtr err);
 399
 400 virDomainPtr
 401 virDomainLookupByNameWrapper(virConnectPtr conn,
 402                              const char *name,
 403                              virErrorPtr err);
 404
 405 virDomainPtr
 406 virDomainLookupByUUIDWrapper(virConnectPtr conn,
 407                              const unsigned char *uuid,
 408                              virErrorPtr err);
 409
 410 virDomainPtr
 411 virDomainLookupByUUIDStringWrapper(virConnectPtr conn,
 412                                    const char *uuidstr,
 413                                    virErrorPtr err);
 414
 415 int
 416 virDomainRestoreWrapper(virConnectPtr conn,
 417                         const char *from,
 418                         virErrorPtr err);
 419
 420 int
 421 virDomainRestoreFlagsWrapper(virConnectPtr conn,
 422                              const char *from,
 423                              const char *dxml,
 424                              unsigned int flags,
 425                              virErrorPtr err);
 426
 427 int
 428 virDomainSaveImageDefineXMLWrapper(virConnectPtr conn,
 429                                    const char *file,
 430                                    const char *dxml,
 431                                    unsigned int flags,
 432                                    virErrorPtr err);
 433
 434 char *
 435 virDomainSaveImageGetXMLDescWrapper(virConnectPtr conn,
 436                                     const char *file,
 437                                     unsigned int flags,
 438                                     virErrorPtr err);
 439
 440 void
 441 virDomainStatsRecordListFreeWrapper(virDomainStatsRecordPtr *stats);
 442
 443 int
 444 virGetVersionWrapper(unsigned long *libVer,
 445                      const char *type,
 446                      unsigned long *typeVer,
 447                      virErrorPtr err);
 448
 449 int
 450 virInterfaceChangeBeginWrapper(virConnectPtr conn,
 451                                unsigned int flags,
 452                                virErrorPtr err);
 453
 454 int
 455 virInterfaceChangeCommitWrapper(virConnectPtr conn,
 456                                 unsigned int flags,
 457                                 virErrorPtr err);
 458
 459 int
 460 virInterfaceChangeRollbackWrapper(virConnectPtr conn,
 461                                   unsigned int flags,
 462                                   virErrorPtr err);
 463
 464 virInterfacePtr
 465 virInterfaceDefineXMLWrapper(virConnectPtr conn,
 466                              const char *xml,
 467                              unsigned int flags,
 468                              virErrorPtr err);
 469
 470 virInterfacePtr
 471 virInterfaceLookupByMACStringWrapper(virConnectPtr conn,
 472                                      const char *macstr,
 473                                      virErrorPtr err);
 474
 475 virInterfacePtr
 476 virInterfaceLookupByNameWrapper(virConnectPtr conn,
 477                                 const char *name,
 478                                 virErrorPtr err);
 479
 480 virNWFilterBindingPtr
 481 virNWFilterBindingCreateXMLWrapper(virConnectPtr conn,
 482                                    const char *xml,
 483                                    unsigned int flags,
 484                                    virErrorPtr err);
 485
 486 virNWFilterBindingPtr
 487 virNWFilterBindingLookupByPortDevWrapper(virConnectPtr conn,
 488                                          const char *portdev,
 489                                          virErrorPtr err);
 490
 491 virNWFilterPtr
 492 virNWFilterDefineXMLWrapper(virConnectPtr conn,
 493                             const char *xmlDesc,
 494                             virErrorPtr err);
 495
 496 virNWFilterPtr
 497 virNWFilterLookupByNameWrapper(virConnectPtr conn,
 498                                const char *name,
 499                                virErrorPtr err);
 500
 501 virNWFilterPtr
 502 virNWFilterLookupByUUIDWrapper(virConnectPtr conn,
 503                                const unsigned char *uuid,
 504                                virErrorPtr err);
 505
 506 virNWFilterPtr
 507 virNWFilterLookupByUUIDStringWrapper(virConnectPtr conn,
 508                                      const char *uuidstr,
 509                                      virErrorPtr err);
 510
 511 virNetworkPtr
 512 virNetworkCreateXMLWrapper(virConnectPtr conn,
 513                            const char *xmlDesc,
 514                            virErrorPtr err);
 515
 516 virNetworkPtr
 517 virNetworkDefineXMLWrapper(virConnectPtr conn,
 518                            const char *xml,
 519                            virErrorPtr err);
 520
 521 virNetworkPtr
 522 virNetworkLookupByNameWrapper(virConnectPtr conn,
 523                               const char *name,
 524                               virErrorPtr err);
 525
 526 virNetworkPtr
 527 virNetworkLookupByUUIDWrapper(virConnectPtr conn,
 528                               const unsigned char *uuid,
 529                               virErrorPtr err);
 530
 531 virNetworkPtr
 532 virNetworkLookupByUUIDStringWrapper(virConnectPtr conn,
 533                                     const char *uuidstr,
 534                                     virErrorPtr err);
 535
 536 int
 537 virNodeAllocPagesWrapper(virConnectPtr conn,
 538                          unsigned int npages,
 539                          unsigned int *pageSizes,
 540                          unsigned long long *pageCounts,
 541                          int startCell,
 542                          unsigned int cellCount,
 543                          unsigned int flags,
 544                          virErrorPtr err);
 545
 546 virNodeDevicePtr
 547 virNodeDeviceCreateXMLWrapper(virConnectPtr conn,
 548                               const char *xmlDesc,
 549                               unsigned int flags,
 550                               virErrorPtr err);
 551
 552 virNodeDevicePtr
 553 virNodeDeviceLookupByNameWrapper(virConnectPtr conn,
 554                                  const char *name,
 555                                  virErrorPtr err);
 556
 557 virNodeDevicePtr
 558 virNodeDeviceLookupSCSIHostByWWNWrapper(virConnectPtr conn,
 559                                         const char *wwnn,
 560                                         const char *wwpn,
 561                                         unsigned int flags,
 562                                         virErrorPtr err);
 563
 564 int
 565 virNodeGetCPUMapWrapper(virConnectPtr conn,
 566                         unsigned char **cpumap,
 567                         unsigned int *online,
 568                         unsigned int flags,
 569                         virErrorPtr err);
 570
 571 int
 572 virNodeGetCPUStatsWrapper(virConnectPtr conn,
 573                           int cpuNum,
 574                           virNodeCPUStatsPtr params,
 575                           int *nparams,
 576                           unsigned int flags,
 577                           virErrorPtr err);
 578
 579 int
 580 virNodeGetCellsFreeMemoryWrapper(virConnectPtr conn,
 581                                  unsigned long long *freeMems,
 582                                  int startCell,
 583                                  int maxCells,
 584                                  virErrorPtr err);
 585
 586 unsigned long long
 587 virNodeGetFreeMemoryWrapper(virConnectPtr conn,
 588                             virErrorPtr err);
 589
 590 int
 591 virNodeGetFreePagesWrapper(virConnectPtr conn,
 592                            unsigned int npages,
 593                            unsigned int *pages,
 594                            int startCell,
 595                            unsigned int cellCount,
 596                            unsigned long long *counts,
 597                            unsigned int flags,
 598                            virErrorPtr err);
 599
 600 int
 601 virNodeGetInfoWrapper(virConnectPtr conn,
 602                       virNodeInfoPtr info,
 603                       virErrorPtr err);
 604
 605 int
 606 virNodeGetMemoryParametersWrapper(virConnectPtr conn,
 607                                   virTypedParameterPtr params,
 608                                   int *nparams,
 609                                   unsigned int flags,
 610                                   virErrorPtr err);
 611
 612 int
 613 virNodeGetMemoryStatsWrapper(virConnectPtr conn,
 614                              int cellNum,
 615                              virNodeMemoryStatsPtr params,
 616                              int *nparams,
 617                              unsigned int flags,
 618                              virErrorPtr err);
 619
 620 int
 621 virNodeGetSEVInfoWrapper(virConnectPtr conn,
 622                          virTypedParameterPtr *params,
 623                          int *nparams,
 624                          unsigned int flags,
 625                          virErrorPtr err);
 626
 627 int
 628 virNodeGetSecurityModelWrapper(virConnectPtr conn,
 629                                virSecurityModelPtr secmodel,
 630                                virErrorPtr err);
 631
 632 int
 633 virNodeListDevicesWrapper(virConnectPtr conn,
 634                           const char *cap,
 635                           char **const names,
 636                           int maxnames,
 637                           unsigned int flags,
 638                           virErrorPtr err);
 639
 640 int
 641 virNodeNumOfDevicesWrapper(virConnectPtr conn,
 642                            const char *cap,
 643                            unsigned int flags,
 644                            virErrorPtr err);
 645
 646 int
 647 virNodeSetMemoryParametersWrapper(virConnectPtr conn,
 648                                   virTypedParameterPtr params,
 649                                   int nparams,
 650                                   unsigned int flags,
 651                                   virErrorPtr err);
 652
 653 int
 654 virNodeSuspendForDurationWrapper(virConnectPtr conn,
 655                                  unsigned int target,
 656                                  unsigned long long duration,
 657                                  unsigned int flags,
 658                                  virErrorPtr err);
 659
 660 virSecretPtr
 661 virSecretDefineXMLWrapper(virConnectPtr conn,
 662                           const char *xml,
 663                           unsigned int flags,
 664                           virErrorPtr err);
 665
 666 virSecretPtr
 667 virSecretLookupByUUIDWrapper(virConnectPtr conn,
 668                              const unsigned char *uuid,
 669                              virErrorPtr err);
 670
 671 virSecretPtr
 672 virSecretLookupByUUIDStringWrapper(virConnectPtr conn,
 673                                    const char *uuidstr,
 674                                    virErrorPtr err);
 675
 676 virSecretPtr
 677 virSecretLookupByUsageWrapper(virConnectPtr conn,
 678                               int usageType,
 679                               const char *usageID,
 680                               virErrorPtr err);
 681
 682 virStoragePoolPtr
 683 virStoragePoolCreateXMLWrapper(virConnectPtr conn,
 684                                const char *xmlDesc,
 685                                unsigned int flags,
 686                                virErrorPtr err);
 687
 688 virStoragePoolPtr
 689 virStoragePoolDefineXMLWrapper(virConnectPtr conn,
 690                                const char *xml,
 691                                unsigned int flags,
 692                                virErrorPtr err);
 693
 694 virStoragePoolPtr
 695 virStoragePoolLookupByNameWrapper(virConnectPtr conn,
 696                                   const char *name,
 697                                   virErrorPtr err);
 698
 699 virStoragePoolPtr
 700 virStoragePoolLookupByTargetPathWrapper(virConnectPtr conn,
 701                                         const char *path,
 702                                         virErrorPtr err);
 703
 704 virStoragePoolPtr
 705 virStoragePoolLookupByUUIDWrapper(virConnectPtr conn,
 706                                   const unsigned char *uuid,
 707                                   virErrorPtr err);
 708
 709 virStoragePoolPtr
 710 virStoragePoolLookupByUUIDStringWrapper(virConnectPtr conn,
 711                                         const char *uuidstr,
 712                                         virErrorPtr err);
 713
 714 virStorageVolPtr
 715 virStorageVolLookupByKeyWrapper(virConnectPtr conn,
 716                                 const char *key,
 717                                 virErrorPtr err);
 718
 719 virStorageVolPtr
 720 virStorageVolLookupByPathWrapper(virConnectPtr conn,
 721                                  const char *path,
 722                                  virErrorPtr err);
 723
 724 virStreamPtr
 725 virStreamNewWrapper(virConnectPtr conn,
 726                     unsigned int flags,
 727                     virErrorPtr err);
 728
 729
 730 #endif /* LIBVIRT_GO_CONNECT_WRAPPER_H__ */