1 /* 2 * datatypes.h: management of structs for public data types 3 * 4 * Copyright (C) 2006-2019 Red Hat, Inc. 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library. If not, see 18 * <http://www.gnu.org/licenses/>. 19 * 20 */ 21 22 #pragma once 23 24 #include "internal.h" 25 26 #include "driver.h" 27 #include "virthread.h" 28 #include "virobject.h" 29 #include "viruuid.h" 30 31 extern virClass *virConnectClass; 32 extern virClass *virDomainClass; 33 extern virClass *virDomainCheckpointClass; 34 extern virClass *virDomainSnapshotClass; 35 extern virClass *virInterfaceClass; 36 extern virClass *virNetworkClass; 37 extern virClass *virNetworkPortClass; 38 extern virClass *virNodeDeviceClass; 39 extern virClass *virNWFilterClass; 40 extern virClass *virNWFilterBindingClass; 41 extern virClass *virSecretClass; 42 extern virClass *virStreamClass; 43 extern virClass *virStorageVolClass; 44 extern virClass *virStoragePoolClass; 45 46 extern virClass *virAdmConnectClass; 47 extern virClass *virAdmServerClass; 48 extern virClass *virAdmClientClass; 49 50 #define virCheckConnectReturn(obj, retval) \ 51 do { \ 52 if (!virObjectIsClass(obj, virConnectClass)) { \ 53 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 54 __FILE__, __FUNCTION__, __LINE__, \ 55 __FUNCTION__); \ 56 virDispatchError(NULL); \ 57 return retval; \ 58 } \ 59 } while (0) 60 #define virCheckConnectGoto(obj, label) \ 61 do { \ 62 if (!virObjectIsClass(obj, virConnectClass)) { \ 63 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 64 __FILE__, __FUNCTION__, __LINE__, \ 65 __FUNCTION__); \ 66 goto label; \ 67 } \ 68 } while (0) 69 70 #define virCheckDomainReturn(obj, retval) \ 71 do { \ 72 virDomainPtr _dom = (obj); \ 73 if (!virObjectIsClass(_dom, virDomainClass) || \ 74 !virObjectIsClass(_dom->conn, virConnectClass)) { \ 75 virReportErrorHelper(VIR_FROM_DOM, VIR_ERR_INVALID_DOMAIN, \ 76 __FILE__, __FUNCTION__, __LINE__, \ 77 __FUNCTION__); \ 78 virDispatchError(NULL); \ 79 return retval; \ 80 } \ 81 } while (0) 82 #define virCheckDomainGoto(obj, label) \ 83 do { \ 84 virDomainPtr _dom = (obj); \ 85 if (!virObjectIsClass(_dom, virDomainClass) || \ 86 !virObjectIsClass(_dom->conn, virConnectClass)) { \ 87 virReportErrorHelper(VIR_FROM_DOM, VIR_ERR_INVALID_DOMAIN, \ 88 __FILE__, __FUNCTION__, __LINE__, \ 89 __FUNCTION__); \ 90 goto label; \ 91 } \ 92 } while (0) 93 94 #define virCheckNetworkReturn(obj, retval) \ 95 do { \ 96 virNetworkPtr _net = (obj); \ 97 if (!virObjectIsClass(_net, virNetworkClass) || \ 98 !virObjectIsClass(_net->conn, virConnectClass)) { \ 99 virReportErrorHelper(VIR_FROM_NETWORK, \ 100 VIR_ERR_INVALID_NETWORK, \ 101 __FILE__, __FUNCTION__, __LINE__, \ 102 __FUNCTION__); \ 103 virDispatchError(NULL); \ 104 return retval; \ 105 } \ 106 } while (0) 107 #define virCheckNetworkGoto(obj, label) \ 108 do { \ 109 virNetworkPtr _net = (obj); \ 110 if (!virObjectIsClass(_net, virNetworkClass) || \ 111 !virObjectIsClass(_net->conn, virConnectClass)) { \ 112 virReportErrorHelper(VIR_FROM_NETWORK, \ 113 VIR_ERR_INVALID_NETWORK, \ 114 __FILE__, __FUNCTION__, __LINE__, \ 115 __FUNCTION__); \ 116 goto label; \ 117 } \ 118 } while (0) 119 120 #define virCheckNetworkPortReturn(obj, retval) \ 121 do { \ 122 virNetworkPortPtr _port = (obj); \ 123 if (!virObjectIsClass(_port, virNetworkPortClass) || \ 124 !virObjectIsClass(_port->net, virNetworkClass)) { \ 125 virReportErrorHelper(VIR_FROM_NETWORK, \ 126 VIR_ERR_INVALID_NETWORK_PORT, \ 127 __FILE__, __FUNCTION__, __LINE__, \ 128 __FUNCTION__); \ 129 virDispatchError(NULL); \ 130 return retval; \ 131 } \ 132 } while (0) 133 134 #define virCheckNetworkPortGoto(obj, label) \ 135 do { \ 136 virNetworkPortPtr _port = (obj); \ 137 if (!virObjectIsClass(_port, virNetworkPortClass) || \ 138 !virObjectIsClass(_port->net, virNetworkClass)) { \ 139 virReportErrorHelper(VIR_FROM_NETWORK, \ 140 VIR_ERR_INVALID_NETWORK_PORT, \ 141 __FILE__, __FUNCTION__, __LINE__, \ 142 __FUNCTION__); \ 143 goto label; \ 144 } \ 145 } while (0) 146 147 #define virCheckInterfaceReturn(obj, retval) \ 148 do { \ 149 virInterfacePtr _iface = (obj); \ 150 if (!virObjectIsClass(_iface, virInterfaceClass) || \ 151 !virObjectIsClass(_iface->conn, virConnectClass)) { \ 152 virReportErrorHelper(VIR_FROM_INTERFACE, \ 153 VIR_ERR_INVALID_INTERFACE, \ 154 __FILE__, __FUNCTION__, __LINE__, \ 155 __FUNCTION__); \ 156 virDispatchError(NULL); \ 157 return retval; \ 158 } \ 159 } while (0) 160 161 #define virCheckStoragePoolReturn(obj, retval) \ 162 do { \ 163 virStoragePoolPtr _pool = (obj); \ 164 if (!virObjectIsClass(_pool, virStoragePoolClass) || \ 165 !virObjectIsClass(_pool->conn, virConnectClass)) { \ 166 virReportErrorHelper(VIR_FROM_STORAGE, \ 167 VIR_ERR_INVALID_STORAGE_POOL, \ 168 __FILE__, __FUNCTION__, __LINE__, \ 169 __FUNCTION__); \ 170 virDispatchError(NULL); \ 171 return retval; \ 172 } \ 173 } while (0) 174 175 #define virCheckStoragePoolGoto(obj, label) \ 176 do { \ 177 virStoragePoolPtr _pool= (obj); \ 178 if (!virObjectIsClass(_pool, virStoragePoolClass) || \ 179 !virObjectIsClass(_pool->conn, virConnectClass)) { \ 180 virReportErrorHelper(VIR_FROM_STORAGE, \ 181 VIR_ERR_INVALID_STORAGE_POOL, \ 182 __FILE__, __FUNCTION__, __LINE__, \ 183 __FUNCTION__); \ 184 goto label; \ 185 } \ 186 } while (0) 187 188 #define virCheckStorageVolReturn(obj, retval) \ 189 do { \ 190 virStorageVolPtr _vol = (obj); \ 191 if (!virObjectIsClass(_vol, virStorageVolClass) || \ 192 !virObjectIsClass(_vol->conn, virConnectClass)) { \ 193 virReportErrorHelper(VIR_FROM_STORAGE, \ 194 VIR_ERR_INVALID_STORAGE_VOL, \ 195 __FILE__, __FUNCTION__, __LINE__, \ 196 __FUNCTION__); \ 197 virDispatchError(NULL); \ 198 return retval; \ 199 } \ 200 } while (0) 201 #define virCheckStorageVolGoto(obj, label) \ 202 do { \ 203 virStorageVolPtr _vol = (obj); \ 204 if (!virObjectIsClass(_vol, virStorageVolClass) || \ 205 !virObjectIsClass(_vol->conn, virConnectClass)) { \ 206 virReportErrorHelper(VIR_FROM_STORAGE, \ 207 VIR_ERR_INVALID_STORAGE_VOL, \ 208 __FILE__, __FUNCTION__, __LINE__, \ 209 __FUNCTION__); \ 210 goto label; \ 211 } \ 212 } while (0) 213 214 #define virCheckNodeDeviceReturn(obj, retval) \ 215 do { \ 216 virNodeDevicePtr _node = (obj); \ 217 if (!virObjectIsClass(_node, virNodeDeviceClass) || \ 218 !virObjectIsClass(_node->conn, virConnectClass)) { \ 219 virReportErrorHelper(VIR_FROM_NODEDEV, \ 220 VIR_ERR_INVALID_NODE_DEVICE, \ 221 __FILE__, __FUNCTION__, __LINE__, \ 222 __FUNCTION__); \ 223 virDispatchError(NULL); \ 224 return retval; \ 225 } \ 226 } while (0) 227 228 #define virCheckNodeDeviceGoto(obj, label) \ 229 do { \ 230 virNodeDevicePtr _dev= (obj); \ 231 if (!virObjectIsClass(_dev, virNodeDeviceClass) || \ 232 !virObjectIsClass(_dev->conn, virConnectClass)) { \ 233 virReportErrorHelper(VIR_FROM_NODEDEV, \ 234 VIR_ERR_INVALID_NODE_DEVICE, \ 235 __FILE__, __FUNCTION__, __LINE__, \ 236 __FUNCTION__); \ 237 goto label; \ 238 } \ 239 } while (0) 240 241 #define virCheckSecretReturn(obj, retval) \ 242 do { \ 243 virSecretPtr _secret = (obj); \ 244 if (!virObjectIsClass(_secret, virSecretClass) || \ 245 !virObjectIsClass(_secret->conn, virConnectClass)) { \ 246 virReportErrorHelper(VIR_FROM_SECRET, \ 247 VIR_ERR_INVALID_SECRET, \ 248 __FILE__, __FUNCTION__, __LINE__, \ 249 __FUNCTION__); \ 250 virDispatchError(NULL); \ 251 return retval; \ 252 } \ 253 } while (0) 254 255 #define virCheckSecretGoto(obj, label) \ 256 do { \ 257 virSecretPtr _secret = (obj); \ 258 if (!virObjectIsClass(_secret, virSecretClass) || \ 259 !virObjectIsClass(_secret->conn, virConnectClass)) { \ 260 virReportErrorHelper(VIR_FROM_SECRET, \ 261 VIR_ERR_INVALID_SECRET, \ 262 __FILE__, __FUNCTION__, __LINE__, \ 263 __FUNCTION__); \ 264 virDispatchError(NULL); \ 265 goto label; \ 266 } \ 267 } while (0) 268 269 #define virCheckStreamReturn(obj, retval) \ 270 do { \ 271 virStreamPtr _st = (obj); \ 272 if (!virObjectIsClass(_st, virStreamClass) || \ 273 !virObjectIsClass(_st->conn, virConnectClass)) { \ 274 virReportErrorHelper(VIR_FROM_STREAMS, \ 275 VIR_ERR_INVALID_STREAM, \ 276 __FILE__, __FUNCTION__, __LINE__, \ 277 __FUNCTION__); \ 278 virDispatchError(NULL); \ 279 return retval; \ 280 } \ 281 } while (0) 282 #define virCheckStreamGoto(obj, label) \ 283 do { \ 284 virStreamPtr _st = (obj); \ 285 if (!virObjectIsClass(_st, virStreamClass) || \ 286 !virObjectIsClass(_st->conn, virConnectClass)) { \ 287 virReportErrorHelper(VIR_FROM_STREAMS, \ 288 VIR_ERR_INVALID_STREAM, \ 289 __FILE__, __FUNCTION__, __LINE__, \ 290 __FUNCTION__); \ 291 goto label; \ 292 } \ 293 } while (0) 294 295 #define virCheckNWFilterReturn(obj, retval) \ 296 do { \ 297 virNWFilterPtr _nw = (obj); \ 298 if (!virObjectIsClass(_nw, virNWFilterClass) || \ 299 !virObjectIsClass(_nw->conn, virConnectClass)) { \ 300 virReportErrorHelper(VIR_FROM_NWFILTER, \ 301 VIR_ERR_INVALID_NWFILTER, \ 302 __FILE__, __FUNCTION__, __LINE__, \ 303 __FUNCTION__); \ 304 virDispatchError(NULL); \ 305 return retval; \ 306 } \ 307 } while (0) 308 309 #define virCheckNWFilterBindingReturn(obj, retval) \ 310 do { \ 311 virNWFilterBindingPtr _nw = (obj); \ 312 if (!virObjectIsClass(_nw, virNWFilterBindingClass) || \ 313 !virObjectIsClass(_nw->conn, virConnectClass)) { \ 314 virReportErrorHelper(VIR_FROM_NWFILTER, \ 315 VIR_ERR_INVALID_NWFILTER_BINDING, \ 316 __FILE__, __FUNCTION__, __LINE__, \ 317 __FUNCTION__); \ 318 virDispatchError(NULL); \ 319 return retval; \ 320 } \ 321 } while (0) 322 323 #define virCheckDomainCheckpointReturn(obj, retval) \ 324 do { \ 325 virDomainCheckpointPtr _check = (obj); \ 326 if (!virObjectIsClass(_check, virDomainCheckpointClass) || \ 327 !virObjectIsClass(_check->domain, virDomainClass) || \ 328 !virObjectIsClass(_check->domain->conn, virConnectClass)) { \ 329 virReportErrorHelper(VIR_FROM_DOMAIN_CHECKPOINT, \ 330 VIR_ERR_INVALID_DOMAIN_CHECKPOINT, \ 331 __FILE__, __FUNCTION__, __LINE__, \ 332 __FUNCTION__); \ 333 virDispatchError(NULL); \ 334 return retval; \ 335 } \ 336 } while (0) 337 338 #define virCheckDomainSnapshotReturn(obj, retval) \ 339 do { \ 340 virDomainSnapshotPtr _snap = (obj); \ 341 if (!virObjectIsClass(_snap, virDomainSnapshotClass) || \ 342 !virObjectIsClass(_snap->domain, virDomainClass) || \ 343 !virObjectIsClass(_snap->domain->conn, virConnectClass)) { \ 344 virReportErrorHelper(VIR_FROM_DOMAIN_SNAPSHOT, \ 345 VIR_ERR_INVALID_DOMAIN_SNAPSHOT, \ 346 __FILE__, __FUNCTION__, __LINE__, \ 347 __FUNCTION__); \ 348 virDispatchError(NULL); \ 349 return retval; \ 350 } \ 351 } while (0) 352 353 354 /* Helper macros to implement VIR_DOMAIN_DEBUG using just C99. This 355 * assumes you pass fewer than 15 arguments to VIR_DOMAIN_DEBUG, but 356 * can easily be expanded if needed. 357 * 358 * Note that gcc provides extensions of "define a(b...) b" or 359 * "define a(b,...) b,##__VA_ARGS__" as a means of eliding a comma 360 * when no var-args are present, but we don't want to require gcc. 361 */ 362 #define VIR_ARG15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ 363 _11, _12, _13, _14, _15, ...) _15 364 #define VIR_HAS_COMMA(...) VIR_ARG15(__VA_ARGS__, \ 365 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0) 366 367 /* Form the name VIR_DOMAIN_DEBUG_[01], then call that macro, 368 * according to how many arguments are present. Two-phase due to 369 * macro expansion rules. */ 370 #define VIR_DOMAIN_DEBUG_EXPAND(a, b, ...) \ 371 VIR_DOMAIN_DEBUG_PASTE(a, b, __VA_ARGS__) 372 #define VIR_DOMAIN_DEBUG_PASTE(a, b, ...) \ 373 a##b(__VA_ARGS__) 374 375 /* Internal use only, when VIR_DOMAIN_DEBUG has one argument. */ 376 #define VIR_DOMAIN_DEBUG_0(dom) \ 377 VIR_DOMAIN_DEBUG_2(dom, "%s", "") 378 379 /* Internal use only, when VIR_DOMAIN_DEBUG has three or more arguments. */ 380 #define VIR_DOMAIN_DEBUG_1(dom, fmt, ...) \ 381 VIR_DOMAIN_DEBUG_2(dom, ", " fmt, __VA_ARGS__) 382 383 /* Internal use only, with final format. */ 384 #define VIR_DOMAIN_DEBUG_2(dom, fmt, ...) \ 385 do { \ 386 char _uuidstr[VIR_UUID_STRING_BUFLEN]; \ 387 const char *_domname = NULL; \ 388 \ 389 if (!virObjectIsClass(dom, virDomainClass)) { \ 390 memset(_uuidstr, 0, sizeof(_uuidstr)); \ 391 } else { \ 392 virUUIDFormat((dom)->uuid, _uuidstr); \ 393 _domname = (dom)->name; \ 394 } \ 395 \ 396 VIR_DEBUG("dom=%p, (VM: name=%s, uuid=%s)" fmt, \ 397 dom, NULLSTR(_domname), _uuidstr, __VA_ARGS__); \ 398 } while (0) 399 400 #define virCheckAdmConnectReturn(obj, retval) \ 401 do { \ 402 if (!virObjectIsClass(obj, virAdmConnectClass)) { \ 403 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 404 __FILE__, __FUNCTION__, __LINE__, \ 405 __FUNCTION__); \ 406 virDispatchError(NULL); \ 407 return retval; \ 408 } \ 409 } while (0) 410 #define virCheckAdmConnectGoto(obj, label) \ 411 do { \ 412 if (!virObjectIsClass(obj, virAdmConnectClass)) { \ 413 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 414 __FILE__, __FUNCTION__, __LINE__, \ 415 __FUNCTION__); \ 416 goto label; \ 417 } \ 418 } while (0) 419 420 #define virCheckAdmServerReturn(obj, retval) \ 421 do { \ 422 virAdmServerPtr _srv = (obj); \ 423 if (!virObjectIsClass(_srv, virAdmServerClass) || \ 424 !virObjectIsClass(_srv->conn, virAdmConnectClass)) { \ 425 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 426 __FILE__, __FUNCTION__, __LINE__, \ 427 __FUNCTION__); \ 428 virDispatchError(NULL); \ 429 return retval; \ 430 } \ 431 } while (0) 432 #define virCheckAdmServerGoto(obj, label) \ 433 do { \ 434 virAdmServerPtr _srv = (obj); \ 435 if (!virObjectIsClass(_srv, virAdmServerClass) || \ 436 !virObjectIsClass(_srv->conn, virAdmConnectClass)) { \ 437 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 438 __FILE__, __FUNCTION__, __LINE__, \ 439 __FUNCTION__); \ 440 goto label; \ 441 } \ 442 } while (0); 443 444 #define virCheckAdmClientReturn(obj, retval) \ 445 do { \ 446 virAdmClientPtr _clt = (obj); \ 447 if (!virObjectIsClass(_clt, virAdmClientClass) || \ 448 !virObjectIsClass(_clt->srv, virAdmServerClass) || \ 449 !virObjectIsClass(_clt->srv->conn, virAdmConnectClass)) { \ 450 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 451 __FILE__, __FUNCTION__, __LINE__, \ 452 __FUNCTION__); \ 453 virDispatchError(NULL); \ 454 return retval; \ 455 } \ 456 } while (0) 457 #define virCheckAdmClientGoto(obj, label) \ 458 do { \ 459 virAdmClientPtr _clt = (obj); \ 460 if (!virObjectIsClass(_clt, virAdmClientClass) || \ 461 !virObjectIsClass(_clt->srv, virAdmServerClass) || \ 462 !virObjectIsClass(_clt->srv->conn, virAdmConnectClass)) { \ 463 virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INVALID_CONN, \ 464 __FILE__, __FUNCTION__, __LINE__, \ 465 __FUNCTION__); \ 466 goto label; \ 467 } \ 468 } while (0); 469 470 /** 471 * VIR_DOMAIN_DEBUG: 472 * @dom: domain 473 * @fmt: optional format for additional information 474 * @...: optional arguments corresponding to @fmt. 475 */ 476 #define VIR_DOMAIN_DEBUG(...) \ 477 VIR_DOMAIN_DEBUG_EXPAND(VIR_DOMAIN_DEBUG_, \ 478 VIR_HAS_COMMA(__VA_ARGS__), \ 479 __VA_ARGS__) 480 481 482 typedef struct _virConnectCloseCallbackData virConnectCloseCallbackData; 483 typedef struct _virAdmConnectCloseCallbackData virAdmConnectCloseCallbackData; 484 485 /** 486 * Internal structures holding data related to connection close callbacks. 487 */ 488 struct _virConnectCloseCallbackData { 489 virObjectLockable parent; 490 491 virConnectPtr conn; 492 virConnectCloseFunc callback; 493 void *opaque; 494 virFreeCallback freeCallback; 495 }; 496 497 struct _virAdmConnectCloseCallbackData { 498 virObjectLockable parent; 499 500 virAdmConnectPtr conn; 501 virAdmConnectCloseFunc callback; 502 void *opaque; 503 virFreeCallback freeCallback; 504 }; 505 506 /** 507 * _virConnect: 508 * 509 * Internal structure associated to a connection 510 */ 511 struct _virConnect { 512 virObjectLockable parent; 513 514 /* All the variables from here, until declared otherwise in one of 515 * the following comments, are setup at time of connection open 516 * and never changed since. Thus no need to lock when accessing 517 * them. 518 */ 519 unsigned int flags; /* a set of connection flags */ 520 virURI *uri; /* connection URI */ 521 522 /* The underlying hypervisor driver and network driver. */ 523 virHypervisorDriver *driver; 524 virNetworkDriver *networkDriver; 525 virInterfaceDriver *interfaceDriver; 526 virStorageDriver *storageDriver; 527 virNodeDeviceDriver *nodeDeviceDriver; 528 virSecretDriver *secretDriver; 529 virNWFilterDriver *nwfilterDriver; 530 531 /* Private data pointer which can be used by domain driver as 532 * it pleases. 533 * NB: 'private' is a reserved word in C++. 534 */ 535 void * privateData; 536 537 /* 538 * Object lock must be acquired before accessing/changing any of 539 * members following this point, or changing the ref count of any 540 * virDomain/virNetwork object associated with this connection. 541 */ 542 543 /* Per-connection error. */ 544 virError err; /* the last error */ 545 virErrorFunc handler; /* associated handler */ 546 void *userData; /* the user data */ 547 }; 548 549 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virConnect, virObjectUnref); 550 551 552 /** 553 * _virAdmConnect: 554 * 555 * Internal structure associated to an admin connection 556 */ 557 struct _virAdmConnect { 558 virObjectLockable parent; 559 virURI *uri; 560 561 void *privateData; 562 virFreeCallback privateDataFreeFunc; 563 564 /* Per-connection close callback */ 565 virAdmConnectCloseCallbackData *closeCallback; 566 }; 567 568 /** 569 * _virAdmServer: 570 * 571 * Internal structure associated to a daemon server 572 */ 573 struct _virAdmServer { 574 virObject parent; 575 virAdmConnectPtr conn; /* pointer back to the admin connection */ 576 char *name; /* the server external name */ 577 }; 578 579 /** 580 * _virAdmClient: 581 * 582 * Internal structure associated to a client connected to daemon 583 */ 584 struct _virAdmClient { 585 virObject parent; 586 virAdmServerPtr srv; /* pointer to the server client is 587 * connected to, which also holds a 588 * reference back to the admin connection 589 */ 590 unsigned long long id; /* client's ID */ 591 long long timestamp; /* connection timestamp */ 592 unsigned int transport; /* connection type as virClientTransport */ 593 }; 594 595 /** 596 * _virDomain: 597 * 598 * Internal structure associated to a domain 599 */ 600 struct _virDomain { 601 virObject parent; 602 virConnectPtr conn; /* pointer back to the connection */ 603 char *name; /* the domain external name */ 604 int id; /* the domain ID */ 605 unsigned char uuid[VIR_UUID_BUFLEN]; /* the domain unique identifier */ 606 }; 607 608 /** 609 * _virNetwork: 610 * 611 * Internal structure associated to a network 612 */ 613 struct _virNetwork { 614 virObject parent; 615 virConnectPtr conn; /* pointer back to the connection */ 616 char *name; /* the network external name */ 617 unsigned char uuid[VIR_UUID_BUFLEN]; /* the network unique identifier */ 618 }; 619 620 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetwork, virObjectUnref); 621 622 623 /** 624 * _virNetworkPort: 625 * 626 * Internal structure associated to a network port 627 */ 628 struct _virNetworkPort { 629 virObject parent; 630 virNetworkPtr net; /* pointer back to the connection */ 631 unsigned char uuid[VIR_UUID_BUFLEN]; /* the network unique identifier */ 632 }; 633 634 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetworkPort, virObjectUnref); 635 636 /* virNetworkDHCPLease is defined in the public API - libvirt-network.h */ 637 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetworkDHCPLease, virNetworkDHCPLeaseFree); 638 639 /** 640 * _virInterface: 641 * 642 * Internal structure associated to a physical host interface 643 */ 644 struct _virInterface { 645 virObject parent; 646 virConnectPtr conn; /* pointer back to the connection */ 647 char *name; /* the network external name */ 648 char *mac; /* the interface MAC address */ 649 }; 650 651 /** 652 * _virStoragePool: 653 * 654 * Internal structure associated to a storage pool 655 */ 656 struct _virStoragePool { 657 virObject parent; 658 virConnectPtr conn; /* pointer back to the connection */ 659 char *name; /* the storage pool external name */ 660 unsigned char uuid[VIR_UUID_BUFLEN]; /* the storage pool unique identifier */ 661 662 /* Private data pointer which can be used by driver as they wish. 663 * Cleanup function pointer can be hooked to provide custom cleanup 664 * operation. 665 */ 666 void *privateData; 667 virFreeCallback privateDataFreeFunc; 668 }; 669 670 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStoragePool, virObjectUnref); 671 672 673 /** 674 * _virStorageVol: 675 * 676 * Internal structure associated to a storage volume 677 */ 678 struct _virStorageVol { 679 virObject parent; 680 virConnectPtr conn; /* pointer back to the connection */ 681 char *pool; /* Pool name of owner */ 682 char *name; /* the storage vol external name */ 683 char *key; /* unique key for storage vol */ 684 685 /* Private data pointer which can be used by driver as they wish. 686 * Cleanup function pointer can be hooked to provide custom cleanup 687 * operation. 688 */ 689 void *privateData; 690 virFreeCallback privateDataFreeFunc; 691 }; 692 693 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageVol, virObjectUnref); 694 695 696 /** 697 * _virNodeDevice: 698 * 699 * Internal structure associated with a node device 700 */ 701 struct _virNodeDevice { 702 virObject parent; 703 virConnectPtr conn; /* pointer back to the connection */ 704 char *name; /* device name (unique on node) */ 705 char *parentName; /* parent device name */ 706 }; 707 708 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNodeDevice, virObjectUnref); 709 710 /** 711 * _virSecret: 712 * 713 * Internal structure associated with a secret 714 */ 715 struct _virSecret { 716 virObject parent; 717 virConnectPtr conn; /* pointer back to the connection */ 718 unsigned char uuid[VIR_UUID_BUFLEN]; /* the secret unique identifier */ 719 int usageType; /* the type of usage */ 720 char *usageID; /* the usage's unique identifier */ 721 }; 722 723 724 typedef int (*virStreamAbortFunc)(virStreamPtr, void *opaque); 725 typedef int (*virStreamFinishFunc)(virStreamPtr, void *opaque); 726 727 /** 728 * _virStream: 729 * 730 * Internal structure associated with an input stream 731 */ 732 struct _virStream { 733 virObject parent; 734 virConnectPtr conn; 735 unsigned int flags; 736 737 virStreamDriver *driver; 738 void *privateData; 739 virFreeCallback ff; 740 }; 741 742 743 /** 744 * _virDomainCheckpoint 745 * 746 * Internal structure associated with a domain checkpoint 747 */ 748 struct _virDomainCheckpoint { 749 virObject parent; 750 char *name; 751 virDomainPtr domain; 752 }; 753 754 755 /** 756 * _virDomainSnapshot 757 * 758 * Internal structure associated with a domain snapshot 759 */ 760 struct _virDomainSnapshot { 761 virObject parent; 762 char *name; 763 virDomainPtr domain; 764 }; 765 766 /** 767 * _virNWFilter: 768 * 769 * Internal structure associated to a network filter 770 */ 771 struct _virNWFilter { 772 virObject parent; 773 virConnectPtr conn; /* pointer back to the connection */ 774 char *name; /* the network filter external name */ 775 unsigned char uuid[VIR_UUID_BUFLEN]; /* the network filter unique identifier */ 776 }; 777 778 779 /** 780 * _virNWFilterBinding: 781 * 782 * Internal structure associated to a network filter port binding 783 */ 784 struct _virNWFilterBinding { 785 virObject parent; 786 virConnectPtr conn; /* pointer back to the connection */ 787 char *portdev; /* the network filter port device name */ 788 char *filtername; /* the network filter name */ 789 }; 790 791 792 /* 793 * Helper APIs for allocating new object instances 794 */ 795 796 virConnectPtr virGetConnect(void); 797 virDomainPtr virGetDomain(virConnectPtr conn, 798 const char *name, 799 const unsigned char *uuid, 800 int id); 801 virNetworkPtr virGetNetwork(virConnectPtr conn, 802 const char *name, 803 const unsigned char *uuid); 804 virNetworkPortPtr virGetNetworkPort(virNetworkPtr net, 805 const unsigned char *uuid); 806 virInterfacePtr virGetInterface(virConnectPtr conn, 807 const char *name, 808 const char *mac); 809 virStoragePoolPtr virGetStoragePool(virConnectPtr conn, 810 const char *name, 811 const unsigned char *uuid, 812 void *privateData, 813 virFreeCallback freeFunc); 814 virStorageVolPtr virGetStorageVol(virConnectPtr conn, 815 const char *pool, 816 const char *name, 817 const char *key, 818 void *privateData, 819 virFreeCallback freeFunc); 820 virNodeDevicePtr virGetNodeDevice(virConnectPtr conn, 821 const char *name); 822 virSecretPtr virGetSecret(virConnectPtr conn, 823 const unsigned char *uuid, 824 int usageType, 825 const char *usageID); 826 virStreamPtr virGetStream(virConnectPtr conn); 827 virNWFilterPtr virGetNWFilter(virConnectPtr conn, 828 const char *name, 829 const unsigned char *uuid); 830 virNWFilterBindingPtr virGetNWFilterBinding(virConnectPtr conn, 831 const char *portdev, 832 const char *filtername); 833 virDomainCheckpointPtr virGetDomainCheckpoint(virDomainPtr domain, 834 const char *name); 835 virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, 836 const char *name); 837 838 virAdmConnectPtr virAdmConnectNew(void); 839 840 virAdmServerPtr virAdmGetServer(virAdmConnectPtr conn, 841 const char *name); 842 843 virAdmClientPtr virAdmGetClient(virAdmServerPtr srv, 844 unsigned long long id, 845 unsigned long long timestamp, 846 unsigned int transport); 847 848 /* Thread local to watch if an ObjectUnref causes a Dispoe */ 849 void virConnectWatchDispose(void); 850 bool virConnectWasDisposed(void); 851 void virAdmConnectWatchDispose(void); 852 bool virAdmConnectWasDisposed(void); 853 854 virConnectCloseCallbackData *virNewConnectCloseCallbackData(void); 855 void virConnectCloseCallbackDataRegister(virConnectCloseCallbackData *close, 856 virConnectPtr conn, 857 virConnectCloseFunc cb, 858 void *opaque, 859 virFreeCallback freecb); 860 void virConnectCloseCallbackDataUnregister(virConnectCloseCallbackData *close, 861 virConnectCloseFunc cb); 862 void virConnectCloseCallbackDataCall(virConnectCloseCallbackData *close, 863 int reason); 864 virConnectCloseFunc 865 virConnectCloseCallbackDataGetCallback(virConnectCloseCallbackData *close); 866 void virAdmConnectCloseCallbackDataReset(virAdmConnectCloseCallbackData *cbdata); 867 int virAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackData *cbdata, 868 virAdmConnectPtr conn, 869 virAdmConnectCloseFunc cb, 870 void *opaque, 871 virFreeCallback freecb); 872 int virAdmConnectCloseCallbackDataUnregister(virAdmConnectCloseCallbackData *cbdata, 873 virAdmConnectCloseFunc cb); 874