src/libvirt-secret.c

   1 /*
   2  * libvirt-secret.c: entry points for virSecretPtr APIs
   3  *
   4  * Copyright (C) 2006-2015 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 #include <config.h>
  22
  23 #include "datatypes.h"
  24 #include "virlog.h"
  25
  26 VIR_LOG_INIT("libvirt.secret");
  27
  28 #define VIR_FROM_THIS VIR_FROM_SECRET
  29
  30 /**
  31  * virSecretGetConnect:
  32  * @secret: A virSecret secret
  33  *
  34  * Provides the connection pointer associated with a secret.  The reference
  35  * counter on the connection is not increased by this call.
  36  *
  37  * Returns the virConnectPtr or NULL in case of failure.
  38  *
  39  * Since: 0.7.1
  40  */
  41 virConnectPtr
  42 virSecretGetConnect(virSecretPtr secret)
  43 {
  44     VIR_DEBUG("secret=%p", secret);
  45
  46     virResetLastError();
  47
  48     virCheckSecretReturn(secret, NULL);
  49
  50     return secret->conn;
  51 }
  52
  53
  54 /**
  55  * virConnectNumOfSecrets:
  56  * @conn: virConnect connection
  57  *
  58  * Fetch number of currently defined secrets.
  59  *
  60  * Returns the number currently defined secrets.
  61  *
  62  * Since: 0.7.1
  63  */
  64 int
  65 virConnectNumOfSecrets(virConnectPtr conn)
  66 {
  67     VIR_DEBUG("conn=%p", conn);
  68
  69     virResetLastError();
  70
  71     virCheckConnectReturn(conn, -1);
  72
  73     if (conn->secretDriver != NULL &&
  74         conn->secretDriver->connectNumOfSecrets != NULL) {
  75         int ret;
  76
  77         ret = conn->secretDriver->connectNumOfSecrets(conn);
  78         if (ret < 0)
  79             goto error;
  80         return ret;
  81     }
  82
  83     virReportUnsupportedError();
  84
  85  error:
  86     virDispatchError(conn);
  87     return -1;
  88 }
  89
  90
  91 /**
  92  * virConnectListAllSecrets:
  93  * @conn: Pointer to the hypervisor connection.
  94  * @secrets: Pointer to a variable to store the array containing the secret
  95  *           objects or NULL if the list is not required (just returns the
  96  *           number of secrets).
  97  * @flags: bitwise-OR of virConnectListAllSecretsFlags.
  98  *
  99  * Collect the list of secrets, and allocate an array to store those
 100  * objects.
 101  *
 102  * Normally, all secrets are returned; however, @flags can be used to
 103  * filter the results for a smaller list of targeted secrets. The valid
 104  * flags are divided into groups, where each group contains bits that
 105  * describe mutually exclusive attributes of a secret, and where all bits
 106  * within a group describe all possible secrets.
 107  *
 108  * The first group of @flags is used to filter secrets by its storage
 109  * location. Flag VIR_CONNECT_LIST_SECRETS_EPHEMERAL selects secrets that
 110  * are kept only in memory. Flag VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL
 111  * selects secrets that are kept in persistent storage.
 112  *
 113  * The second group of @flags is used to filter secrets by privacy. Flag
 114  * VIR_CONNECT_LIST_SECRETS_PRIVATE selects secrets that are never revealed
 115  * to any caller of libvirt nor to any other node. Flag
 116  * VIR_CONNECT_LIST_SECRETS_NO_PRIVATE selects non-private secrets.
 117  *
 118  * Returns the number of secrets found or -1 and sets @secrets to NULL in case
 119  * of error.  On success, the array stored into @secrets is guaranteed to
 120  * have an extra allocated element set to NULL but not included in the return count,
 121  * to make iteration easier.  The caller is responsible for calling
 122  * virSecretFree() on each array element, then calling free() on @secrets.
 123  *
 124  * Since: 0.10.2
 125  */
 126 int
 127 virConnectListAllSecrets(virConnectPtr conn,
 128                          virSecretPtr **secrets,
 129                          unsigned int flags)
 130 {
 131     VIR_DEBUG("conn=%p, secrets=%p, flags=0x%x", conn, secrets, flags);
 132
 133     virResetLastError();
 134
 135     if (secrets)
 136         *secrets = NULL;
 137
 138     virCheckConnectReturn(conn, -1);
 139
 140     if (conn->secretDriver &&
 141         conn->secretDriver->connectListAllSecrets) {
 142         int ret;
 143         ret = conn->secretDriver->connectListAllSecrets(conn, secrets, flags);
 144         if (ret < 0)
 145             goto error;
 146         return ret;
 147     }
 148
 149     virReportUnsupportedError();
 150
 151  error:
 152     virDispatchError(conn);
 153     return -1;
 154 }
 155
 156
 157 /**
 158  * virConnectListSecrets:
 159  * @conn: virConnect connection
 160  * @uuids: Pointer to an array to store the UUIDs
 161  * @maxuuids: size of the array.
 162  *
 163  * List UUIDs of defined secrets, store pointers to names in uuids.
 164  *
 165  * The use of this function is discouraged. Instead, use
 166  * virConnectListAllSecrets().
 167  *
 168  * Returns the number of UUIDs provided in the array, or -1 on failure.
 169  *
 170  * Since: 0.7.1
 171  */
 172 int
 173 virConnectListSecrets(virConnectPtr conn, char **uuids, int maxuuids)
 174 {
 175     VIR_DEBUG("conn=%p, uuids=%p, maxuuids=%d", conn, uuids, maxuuids);
 176
 177     virResetLastError();
 178
 179     virCheckConnectReturn(conn, -1);
 180     virCheckNonNullArrayArgGoto(uuids, maxuuids, error);
 181     virCheckNonNegativeArgGoto(maxuuids, error);
 182
 183     if (conn->secretDriver != NULL && conn->secretDriver->connectListSecrets != NULL) {
 184         int ret;
 185
 186         ret = conn->secretDriver->connectListSecrets(conn, uuids, maxuuids);
 187         if (ret < 0)
 188             goto error;
 189         return ret;
 190     }
 191
 192     virReportUnsupportedError();
 193
 194  error:
 195     virDispatchError(conn);
 196     return -1;
 197 }
 198
 199
 200 /**
 201  * virSecretLookupByUUID:
 202  * @conn: pointer to the hypervisor connection
 203  * @uuid: the raw UUID for the secret
 204  *
 205  * Try to lookup a secret on the given hypervisor based on its UUID.
 206  * Uses the 16 bytes of raw data to describe the UUID
 207  *
 208  * virSecretFree should be used to free the resources after the
 209  * secret object is no longer needed.
 210  *
 211  * Returns a new secret object or NULL in case of failure.  If the
 212  * secret cannot be found, then VIR_ERR_NO_SECRET error is raised.
 213  *
 214  * Since: 0.7.1
 215  */
 216 virSecretPtr
 217 virSecretLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
 218 {
 219     VIR_UUID_DEBUG(conn, uuid);
 220
 221     virResetLastError();
 222
 223     virCheckConnectReturn(conn, NULL);
 224     virCheckNonNullArgGoto(uuid, error);
 225
 226     if (conn->secretDriver &&
 227         conn->secretDriver->secretLookupByUUID) {
 228         virSecretPtr ret;
 229         ret = conn->secretDriver->secretLookupByUUID(conn, uuid);
 230         if (!ret)
 231             goto error;
 232         return ret;
 233     }
 234
 235     virReportUnsupportedError();
 236
 237  error:
 238     virDispatchError(conn);
 239     return NULL;
 240 }
 241
 242
 243 /**
 244  * virSecretLookupByUUIDString:
 245  * @conn: pointer to the hypervisor connection
 246  * @uuidstr: the string UUID for the secret
 247  *
 248  * Try to lookup a secret on the given hypervisor based on its UUID.
 249  * Uses the printable string value to describe the UUID
 250  *
 251  * virSecretFree should be used to free the resources after the
 252  * secret object is no longer needed.
 253  *
 254  * Returns a new secret object or NULL in case of failure.  If the
 255  * secret cannot be found, then VIR_ERR_NO_SECRET error is raised.
 256  *
 257  * Since: 0.7.1
 258  */
 259 virSecretPtr
 260 virSecretLookupByUUIDString(virConnectPtr conn, const char *uuidstr)
 261 {
 262     unsigned char uuid[VIR_UUID_BUFLEN];
 263     VIR_DEBUG("conn=%p, uuidstr=%s", conn, NULLSTR(uuidstr));
 264
 265     virResetLastError();
 266
 267     virCheckConnectReturn(conn, NULL);
 268     virCheckNonNullArgGoto(uuidstr, error);
 269
 270     if (virUUIDParse(uuidstr, uuid) < 0) {
 271         virReportInvalidArg(uuidstr,
 272                             _("uuidstr in %1$s must be a valid UUID"),
 273                             __FUNCTION__);
 274         goto error;
 275     }
 276
 277     return virSecretLookupByUUID(conn, &uuid[0]);
 278
 279  error:
 280     virDispatchError(conn);
 281     return NULL;
 282 }
 283
 284
 285 /**
 286  * virSecretLookupByUsage:
 287  * @conn: pointer to the hypervisor connection
 288  * @usageType: the type of secret usage
 289  * @usageID: identifier of the object using the secret
 290  *
 291  * Try to lookup a secret on the given hypervisor based on its usage
 292  * The usageID is unique within the set of secrets sharing the
 293  * same usageType value.
 294  *
 295  * virSecretFree should be used to free the resources after the
 296  * secret object is no longer needed.
 297  *
 298  * Returns a new secret object or NULL in case of failure.  If the
 299  * secret cannot be found, then VIR_ERR_NO_SECRET error is raised.
 300  *
 301  * Since: 0.7.1
 302  */
 303 virSecretPtr
 304 virSecretLookupByUsage(virConnectPtr conn,
 305                        int usageType,
 306                        const char *usageID)
 307 {
 308     VIR_DEBUG("conn=%p, usageType=%d usageID=%s", conn, usageType, NULLSTR(usageID));
 309
 310     virResetLastError();
 311
 312     virCheckConnectReturn(conn, NULL);
 313     virCheckNonNullArgGoto(usageID, error);
 314
 315     if (conn->secretDriver &&
 316         conn->secretDriver->secretLookupByUsage) {
 317         virSecretPtr ret;
 318         ret = conn->secretDriver->secretLookupByUsage(conn, usageType, usageID);
 319         if (!ret)
 320             goto error;
 321         return ret;
 322     }
 323
 324     virReportUnsupportedError();
 325
 326  error:
 327     virDispatchError(conn);
 328     return NULL;
 329 }
 330
 331
 332 /**
 333  * virSecretDefineXML:
 334  * @conn: virConnect connection
 335  * @xml: XML describing the secret.
 336  * @flags: bitwise-OR of virSecretDefineFlags
 337  *
 338  * If XML specifies a UUID, locates the specified secret and replaces all
 339  * attributes of the secret specified by UUID by attributes specified in xml
 340  * (any attributes not specified in xml are discarded).
 341  *
 342  * Otherwise, creates a new secret with an automatically chosen UUID, and
 343  * initializes its attributes from xml.
 344  *
 345  * virSecretFree should be used to free the resources after the
 346  * secret object is no longer needed.
 347  *
 348  * Returns a secret on success, NULL on failure.
 349  *
 350  * Since: 0.7.1
 351  */
 352 virSecretPtr
 353 virSecretDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
 354 {
 355     VIR_DEBUG("conn=%p, xml=%s, flags=0x%x", conn, NULLSTR(xml), flags);
 356
 357     virResetLastError();
 358
 359     virCheckConnectReturn(conn, NULL);
 360     virCheckReadOnlyGoto(conn->flags, error);
 361     virCheckNonNullArgGoto(xml, error);
 362
 363     if (conn->secretDriver != NULL && conn->secretDriver->secretDefineXML != NULL) {
 364         virSecretPtr ret;
 365
 366         ret = conn->secretDriver->secretDefineXML(conn, xml, flags);
 367         if (ret == NULL)
 368             goto error;
 369         return ret;
 370     }
 371
 372     virReportUnsupportedError();
 373
 374  error:
 375     virDispatchError(conn);
 376     return NULL;
 377 }
 378
 379
 380 /**
 381  * virSecretGetUUID:
 382  * @secret: A virSecret secret
 383  * @uuid: buffer of VIR_UUID_BUFLEN bytes in size
 384  *
 385  * Fetches the UUID of the secret.
 386  *
 387  * Returns 0 on success with the uuid buffer being filled, or
 388  * -1 upon failure.
 389  *
 390  * Since: 0.7.1
 391  */
 392 int
 393 virSecretGetUUID(virSecretPtr secret, unsigned char *uuid)
 394 {
 395     VIR_DEBUG("secret=%p", secret);
 396
 397     virResetLastError();
 398
 399     virCheckSecretReturn(secret, -1);
 400     virCheckNonNullArgGoto(uuid, error);
 401
 402     memcpy(uuid, &secret->uuid[0], VIR_UUID_BUFLEN);
 403
 404     return 0;
 405
 406  error:
 407     virDispatchError(secret->conn);
 408     return -1;
 409 }
 410
 411
 412 /**
 413  * virSecretGetUUIDString:
 414  * @secret: a secret object
 415  * @buf: pointer to a VIR_UUID_STRING_BUFLEN bytes array
 416  *
 417  * Get the UUID for a secret as string. For more information about
 418  * UUID see RFC4122.
 419  *
 420  * Returns -1 in case of error, 0 in case of success
 421  *
 422  * Since: 0.7.1
 423  */
 424 int
 425 virSecretGetUUIDString(virSecretPtr secret, char *buf)
 426 {
 427     VIR_DEBUG("secret=%p, buf=%p", secret, buf);
 428
 429     virResetLastError();
 430
 431     virCheckSecretReturn(secret, -1);
 432     virCheckNonNullArgGoto(buf, error);
 433
 434     virUUIDFormat(secret->uuid, buf);
 435     return 0;
 436
 437  error:
 438     virDispatchError(secret->conn);
 439     return -1;
 440 }
 441
 442
 443 /**
 444  * virSecretGetUsageType:
 445  * @secret: a secret object
 446  *
 447  * Get the type of object which uses this secret. The returned
 448  * value is one of the constants defined in the virSecretUsageType
 449  * enumeration. More values may be added to this enumeration in
 450  * the future, so callers should expect to see usage types they
 451  * do not explicitly know about.
 452  *
 453  * Returns a positive integer identifying the type of object,
 454  * or -1 upon error.
 455  *
 456  * Since: 0.7.1
 457  */
 458 int
 459 virSecretGetUsageType(virSecretPtr secret)
 460 {
 461     VIR_DEBUG("secret=%p", secret);
 462
 463     virResetLastError();
 464
 465     virCheckSecretReturn(secret, -1);
 466
 467     return secret->usageType;
 468 }
 469
 470
 471 /**
 472  * virSecretGetUsageID:
 473  * @secret: a secret object
 474  *
 475  * Get the unique identifier of the object with which this
 476  * secret is to be used. The format of the identifier is
 477  * dependent on the usage type of the secret. For a secret
 478  * with a usage type of VIR_SECRET_USAGE_TYPE_VOLUME the
 479  * identifier will be a fully qualified path name. The
 480  * identifiers are intended to be unique within the set of
 481  * all secrets sharing the same usage type. ie, there shall
 482  * only ever be one secret for each volume path.
 483  *
 484  * Returns a string identifying the object using the secret,
 485  * or NULL upon error
 486  *
 487  * Since: 0.7.1
 488  */
 489 const char *
 490 virSecretGetUsageID(virSecretPtr secret)
 491 {
 492     VIR_DEBUG("secret=%p", secret);
 493
 494     virResetLastError();
 495
 496     virCheckSecretReturn(secret, NULL);
 497
 498     return secret->usageID;
 499 }
 500
 501
 502 /**
 503  * virSecretGetXMLDesc:
 504  * @secret: A virSecret secret
 505  * @flags: extra flags; not used yet, so callers should always pass 0
 506  *
 507  * Fetches an XML document describing attributes of the secret.
 508  *
 509  * Returns the XML document on success, NULL on failure.  The caller must
 510  * free() the XML.
 511  *
 512  * Since: 0.7.1
 513  */
 514 char *
 515 virSecretGetXMLDesc(virSecretPtr secret, unsigned int flags)
 516 {
 517     virConnectPtr conn;
 518
 519     VIR_DEBUG("secret=%p, flags=0x%x", secret, flags);
 520
 521     virResetLastError();
 522
 523     virCheckSecretReturn(secret, NULL);
 524     conn = secret->conn;
 525
 526     if (conn->secretDriver != NULL && conn->secretDriver->secretGetXMLDesc != NULL) {
 527         char *ret;
 528
 529         ret = conn->secretDriver->secretGetXMLDesc(secret, flags);
 530         if (ret == NULL)
 531             goto error;
 532         return ret;
 533     }
 534
 535     virReportUnsupportedError();
 536
 537  error:
 538     virDispatchError(conn);
 539     return NULL;
 540 }
 541
 542
 543 /**
 544  * virSecretSetValue:
 545  * @secret: A virSecret secret
 546  * @value: Value of the secret
 547  * @value_size: Size of the value
 548  * @flags: extra flags; not used yet, so callers should always pass 0
 549  *
 550  * Sets the value of a secret.
 551  *
 552  * Returns 0 on success, -1 on failure.
 553  *
 554  * Since: 0.7.1
 555  */
 556 int
 557 virSecretSetValue(virSecretPtr secret, const unsigned char *value,
 558                   size_t value_size, unsigned int flags)
 559 {
 560     virConnectPtr conn;
 561
 562     VIR_DEBUG("secret=%p, value=%p, value_size=%zu, flags=0x%x", secret, value,
 563               value_size, flags);
 564
 565     virResetLastError();
 566
 567     virCheckSecretReturn(secret, -1);
 568     conn = secret->conn;
 569
 570     virCheckReadOnlyGoto(conn->flags, error);
 571     virCheckNonNullArgGoto(value, error);
 572
 573     if (conn->secretDriver != NULL && conn->secretDriver->secretSetValue != NULL) {
 574         int ret;
 575
 576         ret = conn->secretDriver->secretSetValue(secret, value, value_size, flags);
 577         if (ret < 0)
 578             goto error;
 579         return ret;
 580     }
 581
 582     virReportUnsupportedError();
 583
 584  error:
 585     virDispatchError(conn);
 586     return -1;
 587 }
 588
 589
 590 /**
 591  * virSecretGetValue:
 592  * @secret: A virSecret connection
 593  * @value_size: Place for storing size of the secret value
 594  * @flags: extra flags; not used yet, so callers should always pass 0
 595  *
 596  * Fetches the value of a secret.
 597  *
 598  * Returns the secret value on success, NULL on failure.  The caller must
 599  * free() the secret value.
 600  *
 601  * Since: 0.7.1
 602  */
 603 unsigned char *
 604 virSecretGetValue(virSecretPtr secret, size_t *value_size, unsigned int flags)
 605 {
 606     virConnectPtr conn;
 607
 608     VIR_DEBUG("secret=%p, value_size=%p, flags=0x%x", secret, value_size, flags);
 609
 610     virResetLastError();
 611
 612     virCheckSecretReturn(secret, NULL);
 613     conn = secret->conn;
 614
 615     virCheckReadOnlyGoto(conn->flags, error);
 616     virCheckNonNullArgGoto(value_size, error);
 617
 618     if (conn->secretDriver != NULL && conn->secretDriver->secretGetValue != NULL) {
 619         unsigned char *ret;
 620
 621         ret = conn->secretDriver->secretGetValue(secret, value_size, flags);
 622         if (ret == NULL)
 623             goto error;
 624         return ret;
 625     }
 626
 627     virReportUnsupportedError();
 628
 629  error:
 630     virDispatchError(conn);
 631     return NULL;
 632 }
 633
 634
 635 /**
 636  * virSecretUndefine:
 637  * @secret: A virSecret secret
 638  *
 639  * Deletes the specified secret.  This does not free the associated
 640  * virSecretPtr object.
 641  *
 642  * Returns 0 on success, -1 on failure.
 643  *
 644  * Since: 0.7.1
 645  */
 646 int
 647 virSecretUndefine(virSecretPtr secret)
 648 {
 649     virConnectPtr conn;
 650
 651     VIR_DEBUG("secret=%p", secret);
 652
 653     virResetLastError();
 654
 655     virCheckSecretReturn(secret, -1);
 656     conn = secret->conn;
 657
 658     virCheckReadOnlyGoto(conn->flags, error);
 659
 660     if (conn->secretDriver != NULL && conn->secretDriver->secretUndefine != NULL) {
 661         int ret;
 662
 663         ret = conn->secretDriver->secretUndefine(secret);
 664         if (ret < 0)
 665             goto error;
 666         return ret;
 667     }
 668
 669     virReportUnsupportedError();
 670
 671  error:
 672     virDispatchError(conn);
 673     return -1;
 674 }
 675
 676
 677 /**
 678  * virSecretRef:
 679  * @secret: the secret to hold a reference on
 680  *
 681  * Increment the reference count on the secret. For each additional call to
 682  * this method, there shall be a corresponding call to virSecretFree to release
 683  * the reference count, once the caller no longer needs the reference to this
 684  * object.
 685  *
 686  * This method is typically useful for applications where multiple threads are
 687  * using a connection, and it is required that the connection remain open until
 688  * all threads have finished using it. ie, each new thread using a secret would
 689  * increment the reference count.
 690  *
 691  * Returns 0 in case of success, -1 in case of failure.
 692  *
 693  * Since: 0.7.1
 694  */
 695 int
 696 virSecretRef(virSecretPtr secret)
 697 {
 698     VIR_DEBUG("secret=%p", secret);
 699
 700     virResetLastError();
 701
 702     virCheckSecretReturn(secret, -1);
 703
 704     virObjectRef(secret);
 705     return 0;
 706 }
 707
 708
 709 /**
 710  * virSecretFree:
 711  * @secret: pointer to a secret
 712  *
 713  * Release the secret handle. The underlying secret continues to exist.
 714  *
 715  * Returns 0 on success, or -1 on error
 716  *
 717  * Since: 0.7.1
 718  */
 719 int
 720 virSecretFree(virSecretPtr secret)
 721 {
 722     VIR_DEBUG("secret=%p", secret);
 723
 724     virResetLastError();
 725
 726     virCheckSecretReturn(secret, -1);
 727
 728     virObjectUnref(secret);
 729     return 0;
 730 }
 731
 732
 733 /**
 734  * virConnectSecretEventRegisterAny:
 735  * @conn: pointer to the connection
 736  * @secret: pointer to the secret
 737  * @eventID: the event type to receive
 738  * @cb: callback to the function handling secret events
 739  * @opaque: opaque data to pass on to the callback
 740  * @freecb: optional function to deallocate opaque when not used anymore
 741  *
 742  * Adds a callback to receive notifications of arbitrary secret events
 743  * occurring on a secret. This function requires that an event loop
 744  * has been previously registered with virEventRegisterImpl() or
 745  * virEventRegisterDefaultImpl().
 746  *
 747  * If @secret is NULL, then events will be monitored for any secret.
 748  * If @secret is non-NULL, then only the specific secret will be monitored.
 749  *
 750  * Most types of events have a callback providing a custom set of parameters
 751  * for the event. When registering an event, it is thus necessary to use
 752  * the VIR_SECRET_EVENT_CALLBACK() macro to cast the
 753  * supplied function pointer to match the signature of this method.
 754  *
 755  * The virSecretPtr object handle passed into the callback upon delivery
 756  * of an event is only valid for the duration of execution of the callback.
 757  * If the callback wishes to keep the secret object after the callback
 758  * returns, it shall take a reference to it, by calling virSecretRef().
 759  * The reference can be released once the object is no longer required
 760  * by calling virSecretFree().
 761  *
 762  * The return value from this method is a positive integer identifier
 763  * for the callback. To unregister a callback, this callback ID should
 764  * be passed to the virConnectSecretEventDeregisterAny() method.
 765  *
 766  * Returns a callback identifier on success, -1 on failure.
 767  *
 768  * Since: 3.0.0
 769  */
 770 int
 771 virConnectSecretEventRegisterAny(virConnectPtr conn,
 772                                  virSecretPtr secret,
 773                                  int eventID,
 774                                  virConnectSecretEventGenericCallback cb,
 775                                  void *opaque,
 776                                  virFreeCallback freecb)
 777 {
 778     VIR_DEBUG("conn=%p, secret=%p, eventID=%d, cb=%p, opaque=%p, freecb=%p",
 779               conn, secret, eventID, cb, opaque, freecb);
 780
 781     virResetLastError();
 782
 783     virCheckConnectReturn(conn, -1);
 784     if (secret) {
 785         virCheckSecretGoto(secret, error);
 786         if (secret->conn != conn) {
 787             char uuidstr[VIR_UUID_STRING_BUFLEN];
 788             virUUIDFormat(secret->uuid, uuidstr);
 789             virReportInvalidArg(secret,
 790                                 _("secret '%1$s' in %2$s must match connection"),
 791                                 uuidstr, __FUNCTION__);
 792             goto error;
 793         }
 794     }
 795     virCheckNonNullArgGoto(cb, error);
 796     virCheckNonNegativeArgGoto(eventID, error);
 797
 798     if (eventID >= VIR_SECRET_EVENT_ID_LAST) {
 799         virReportInvalidArg(eventID,
 800                             _("eventID in %1$s must be less than %2$d"),
 801                             __FUNCTION__, VIR_SECRET_EVENT_ID_LAST);
 802         goto error;
 803     }
 804
 805     if (conn->secretDriver &&
 806         conn->secretDriver->connectSecretEventRegisterAny) {
 807         int ret;
 808         ret = conn->secretDriver->connectSecretEventRegisterAny(conn,
 809                                                                 secret,
 810                                                                 eventID,
 811                                                                 cb,
 812                                                                 opaque,
 813                                                                 freecb);
 814         if (ret < 0)
 815             goto error;
 816         return ret;
 817     }
 818
 819     virReportUnsupportedError();
 820  error:
 821     virDispatchError(conn);
 822     return -1;
 823 }
 824
 825
 826 /**
 827  * virConnectSecretEventDeregisterAny:
 828  * @conn: pointer to the connection
 829  * @callbackID: the callback identifier
 830  *
 831  * Removes an event callback. The callbackID parameter should be the
 832  * value obtained from a previous virConnectSecretEventRegisterAny() method.
 833  *
 834  * Returns 0 on success, -1 on failure.
 835  *
 836  * Since: 3.0.0
 837  */
 838 int
 839 virConnectSecretEventDeregisterAny(virConnectPtr conn,
 840                                    int callbackID)
 841 {
 842     VIR_DEBUG("conn=%p, callbackID=%d", conn, callbackID);
 843
 844     virResetLastError();
 845
 846     virCheckConnectReturn(conn, -1);
 847     virCheckNonNegativeArgGoto(callbackID, error);
 848
 849     if (conn->secretDriver &&
 850         conn->secretDriver->connectSecretEventDeregisterAny) {
 851         int ret;
 852         ret = conn->secretDriver->connectSecretEventDeregisterAny(conn,
 853                                                                   callbackID);
 854         if (ret < 0)
 855             goto error;
 856         return ret;
 857     }
 858
 859     virReportUnsupportedError();
 860  error:
 861     virDispatchError(conn);
 862     return -1;
 863 }