From 79f6ccd2dc3f0c1369d5a93678c88ee76ec761e0 Mon Sep 17 00:00:00 2001

From: Jakub Hrozek <jhrozek@redhat.com>

Date: Tue, 7 Mar 2017 13:49:21 +0100

Subject: [PATCH 24/36] KCM: Implement an internal ccache storage and retrieval

 API

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

In order for the KCM server to work with ccaches stored in different

locations, implement a middle-man between the KCM server and the ccache

storage.

This module has asynchronous API because we can't assume anything about

where the ccaches are stored.

Reviewed-by: Michal Židek <mzidek@redhat.com>

Reviewed-by: Simo Sorce <simo@redhat.com>

---

 Makefile.am                           |    9 +

 configure.ac                          |    1 +

 contrib/sssd.spec.in                  |    1 +

 src/external/libuuid.m4               |   17 +

 src/responder/kcm/kcmsrv_ccache.c     | 1423 +++++++++++++++++++++++++++++++++

 src/responder/kcm/kcmsrv_ccache.h     |  306 +++++++

 src/responder/kcm/kcmsrv_ccache_be.h  |  204 +++++

 src/responder/kcm/kcmsrv_ccache_pvt.h |   62 ++

 src/responder/kcm/kcmsrv_pvt.h        |    1 +

 9 files changed, 2024 insertions(+)

 create mode 100644 src/external/libuuid.m4

 create mode 100644 src/responder/kcm/kcmsrv_ccache.c

 create mode 100644 src/responder/kcm/kcmsrv_ccache.h

 create mode 100644 src/responder/kcm/kcmsrv_ccache_be.h

 create mode 100644 src/responder/kcm/kcmsrv_ccache_pvt.h

diff --git a/Makefile.am b/Makefile.am

index 4248536e90370c1aab59549a9c18408ef314e6d4..a2b9dc49e95fa2d025f5174d2902866fab180a78 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -711,6 +711,9 @@ dist_noinst_HEADERS = \

     src/responder/secrets/secsrv_proxy.h \

     src/responder/kcm/kcm.h \

     src/responder/kcm/kcmsrv_pvt.h \

+    src/responder/kcm/kcmsrv_ccache.h \

+    src/responder/kcm/kcmsrv_ccache_pvt.h \

+    src/responder/kcm/kcmsrv_ccache_be.h \

     src/sbus/sbus_client.h \

     src/sbus/sssd_dbus.h \

     src/sbus/sssd_dbus_meta.h \

@@ -1488,16 +1491,22 @@ if BUILD_KCM

 sssd_kcm_SOURCES = \

     src/responder/kcm/kcm.c \

     src/responder/kcm/kcmsrv_cmd.c \

+    src/responder/kcm/kcmsrv_ccache.c \

     src/util/sss_sockets.c \

+    src/util/sss_krb5.c \

+    src/util/sss_iobuf.c \

     $(SSSD_RESPONDER_OBJ) \

     $(NULL)

 sssd_kcm_CFLAGS = \

     $(AM_CFLAGS) \

     $(KRB5_CFLAGS) \

+    $(UUID_CFLAGS) \

     $(NULL)

 sssd_kcm_LDADD = \

     $(KRB5_LIBS) \

     $(SSSD_LIBS) \

+    $(UUID_LIBS) \

+    $(SYSTEMD_DAEMON_LIBS) \

     $(SSSD_INTERNAL_LTLIBS) \

     $(NULL)

 endif

diff --git a/configure.ac b/configure.ac

index c363d48a806cc1998e85779a92b6b59b0e2a5c9c..cf5e2557ef0a1bd6374200aa33abea6c509d03aa 100644

--- a/configure.ac

+++ b/configure.ac

@@ -202,6 +202,7 @@ fi

 if test x$with_kcm = xyes; then

     m4_include([src/external/libcurl.m4])

+    m4_include([src/external/libuuid.m4])

 fi

 # This variable is defined by external/libcurl.m4, but conditionals

 # must be always evaluated

diff --git a/contrib/sssd.spec.in b/contrib/sssd.spec.in

index 5c7c2af521a84ef2ca6cca7b2d6cd1f9b3057056..52d33b4de281dc1d91a9027ac1c8c878e66fb396 100644

--- a/contrib/sssd.spec.in

+++ b/contrib/sssd.spec.in

@@ -222,6 +222,7 @@ BuildRequires: systemtap-sdt-devel

 %endif

 BuildRequires: http-parser-devel

 BuildRequires: jansson-devel

+BuildRequires: libuuid-devel

 %description

 Provides a set of daemons to manage access to remote directories and

diff --git a/src/external/libuuid.m4 b/src/external/libuuid.m4

new file mode 100644

index 0000000000000000000000000000000000000000..55411a2118bd787c9d50ba61f9cb791e1c76088d

--- /dev/null

+++ b/src/external/libuuid.m4

@@ -0,0 +1,17 @@

+AC_SUBST(UUID_LIBS)

+AC_SUBST(UUID_CFLAGS)

+

+PKG_CHECK_MODULES([UUID], [uuid], [found_uuid=yes], [found_uuid=no])

+

+SSS_AC_EXPAND_LIB_DIR()

+AS_IF([test x"$found_uuid" = xyes],

+    [AC_CHECK_HEADERS([uuid/uuid.h],

+        [AC_CHECK_LIB([uuid],

+                      [uuid_generate],

+                      [UUID_LIBS="-L$sss_extra_libdir -luuid"],

+                      [AC_MSG_ERROR([libuuid missing uuid_generate])],

+                      [-L$sss_extra_libdir -luuid])],

+        [AC_MSG_ERROR([

+You must have the header file uuid.h installed to build sssd

+with KCM responder. If you want to build sssd without KCM responder

+then specify --without-kcm when running configure.])])])

diff --git a/src/responder/kcm/kcmsrv_ccache.c b/src/responder/kcm/kcmsrv_ccache.c

new file mode 100644

index 0000000000000000000000000000000000000000..2c565b8378e3ec297faf655d3c48d7ab902713d3

--- /dev/null

+++ b/src/responder/kcm/kcmsrv_ccache.c

@@ -0,0 +1,1423 @@

+/*

+   SSSD

+

+   KCM Server - the KCM ccache operations

+

+   Copyright (C) Red Hat, 2016

+

+   This program is free software; you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+   GNU General Public License for more details.

+

+   You should have received a copy of the GNU General Public License

+   along with this program.  If not, see <http://www.gnu.org/licenses/>.

+*/

+

+#include "config.h"

+

+#include "util/crypto/sss_crypto.h"

+#include "util/util.h"

+#include "util/sss_krb5.h"

+#include "responder/kcm/kcmsrv_ccache.h"

+#include "responder/kcm/kcmsrv_ccache_pvt.h"

+#include "responder/kcm/kcmsrv_ccache_be.h"

+

+static int kcm_cc_destructor(struct kcm_ccache *cc)

+{

+    if (cc == NULL) {

+        return 0;

+    }

+

+    krb5_free_principal(NULL, cc->client);

+    return 0;

+}

+

+errno_t kcm_cc_new(TALLOC_CTX *mem_ctx,

+                   krb5_context k5c,

+                   struct cli_creds *owner,

+                   const char *name,

+                   krb5_principal princ,

+                   struct kcm_ccache **_cc)

+{

+    struct kcm_ccache *cc;

+    krb5_error_code kret;

+    errno_t ret;

+

+    cc = talloc_zero(mem_ctx, struct kcm_ccache);

+    if (cc == NULL) {

+        return ENOMEM;

+    }

+

+    ret = kcm_check_name(name, owner);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_CRIT_FAILURE, "Name %s is malformed\n", name);

+        return ret;

+    }

+

+    cc->name = talloc_strdup(cc, name);

+    if (cc->name == NULL) {

+        talloc_free(cc);

+        return ENOMEM;

+    }

+

+    uuid_generate(cc->uuid);

+

+    kret = krb5_copy_principal(k5c, princ, &cc->client);

+    if (kret != 0) {

+        const char *err_msg = sss_krb5_get_error_message(k5c, kret);

+        DEBUG(SSSDBG_OP_FAILURE,

+              "krb5_copy_principal failed: [%d][%s]\n", kret, err_msg);

+        sss_krb5_free_error_message(k5c, err_msg);

+        talloc_free(cc);

+        return ERR_INTERNAL;

+    }

+

+    cc->owner.uid = cli_creds_get_uid(owner);

+    cc->owner.gid = cli_creds_get_gid(owner);

+    cc->kdc_offset = INT32_MAX;

+

+    talloc_set_destructor(cc, kcm_cc_destructor);

+    *_cc = cc;

+    return EOK;

+}

+

+const char *kcm_cc_get_name(struct kcm_ccache *cc)

+{

+    return cc ? cc->name : NULL;

+}

+

+errno_t kcm_cc_get_uuid(struct kcm_ccache *cc, uuid_t _uuid)

+{

+    if (cc == NULL) {

+        return EINVAL;

+    }

+    uuid_copy(_uuid, cc->uuid);

+    return EOK;

+}

+

+krb5_principal kcm_cc_get_client_principal(struct kcm_ccache *cc)

+{

+    return cc ? cc->client : NULL;

+}

+

+bool kcm_cc_access(struct kcm_ccache *cc,

+                   struct cli_creds *client)

+{

+    bool ok;

+    uid_t uid = cli_creds_get_uid(client);

+    gid_t gid = cli_creds_get_gid(client);

+

+    if (cc == NULL) {

+        return false;

+    }

+

+    if (uid == 0 && gid == 0) {

+        /* root can access any ccache */

+        return true;

+    }

+

+    ok = ((cc->owner.uid == uid) && (cc->owner.gid == gid));

+    if (!ok) {

+        DEBUG(SSSDBG_MINOR_FAILURE,

+              "Client %"SPRIuid":%"SPRIgid" has no access to ccache %s\n",

+              cli_creds_get_uid(client),

+              cli_creds_get_gid(client),

+              cc->name);

+    }

+    return ok;

+}

+

+int32_t kcm_cc_get_offset(struct kcm_ccache *cc)

+{

+    return cc ? cc->kdc_offset : INT32_MAX;

+}

+

+errno_t kcm_cc_store_cred_blob(struct kcm_ccache *cc,

+                               struct sss_iobuf *cred_blob)

+{

+    struct kcm_cred *kcreds;

+    uuid_t uuid;

+    errno_t ret;

+

+    if (cc == NULL || cred_blob == NULL) {

+        return EINVAL;

+    }

+

+    uuid_generate(uuid);

+    kcreds = kcm_cred_new(cc, uuid, cred_blob);

+    if (kcreds == NULL) {

+        return ENOMEM;

+    }

+

+    ret = kcm_cc_store_creds(cc, kcreds);

+    if (ret != EOK) {

+        return ret;

+    }

+

+    return EOK;

+}

+

+struct kcm_cred *kcm_cc_get_cred(struct kcm_ccache *cc)

+{

+    if (cc == NULL) {

+        return NULL;

+    }

+

+    return cc->creds;

+}

+

+struct kcm_cred *kcm_cc_next_cred(struct kcm_cred *crd)

+{

+    if (crd == NULL) {

+        return NULL;

+    }

+

+    return crd->next;

+}

+

+struct kcm_cred *kcm_cred_new(TALLOC_CTX *mem_ctx,

+                              uuid_t uuid,

+                              struct sss_iobuf *cred_blob)

+{

+    struct kcm_cred *kcreds;

+

+    kcreds = talloc_zero(mem_ctx, struct kcm_cred);

+    if (kcreds == NULL) {

+        return NULL;

+    }

+

+    uuid_copy(kcreds->uuid, uuid);

+    kcreds->cred_blob = talloc_steal(kcreds, cred_blob);

+    return kcreds;

+}

+

+/* Add a cred to ccache */

+errno_t kcm_cc_store_creds(struct kcm_ccache *cc,

+                           struct kcm_cred *crd)

+{

+    DLIST_ADD(cc->creds, crd);

+    talloc_steal(cc, crd);

+    return EOK;

+}

+

+errno_t kcm_cred_get_uuid(struct kcm_cred *crd, uuid_t _uuid)

+{

+    if (crd == NULL) {

+        return EINVAL;

+    }

+    uuid_copy(_uuid, crd->uuid);

+    return EOK;

+}

+

+struct sss_iobuf *kcm_cred_get_creds(struct kcm_cred *crd)

+{

+    return crd ? crd->cred_blob : NULL;

+}

+

+struct kcm_ccdb *kcm_ccdb_init(TALLOC_CTX *mem_ctx,

+                               struct tevent_context *ev,

+                               enum kcm_ccdb_be cc_be)

+{

+    errno_t ret;

+    struct kcm_ccdb *ccdb = NULL;

+

+    if (ev == NULL) {

+        return NULL;

+    }

+

+    ccdb = talloc_zero(mem_ctx, struct kcm_ccdb);

+    if (ccdb == NULL) {

+        return NULL;

+    }

+    ccdb->ev = ev;

+

+    switch (cc_be) {

+    case CCDB_BE_MEMORY:

+        DEBUG(SSSDBG_FUNC_DATA, "KCM back end: memory\n");

+        /* Not implemented yet */

+        break;

+    case CCDB_BE_SECRETS:

+        DEBUG(SSSDBG_FUNC_DATA, "KCM back end: sssd-secrets\n");

+        /* Not implemented yet */

+        break;

+    default:

+        DEBUG(SSSDBG_CRIT_FAILURE, "Unknown ccache database\n");

+        break;

+    }

+

+    if (ccdb->ops == NULL) {

+        DEBUG(SSSDBG_CRIT_FAILURE, "Ccache database not initialized\n");

+        talloc_free(ccdb);

+        return NULL;

+    }

+

+    ret = ccdb->ops->init(ccdb);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_CRIT_FAILURE, "Cannot initialize ccache database\n");

+        talloc_free(ccdb);

+        return NULL;

+    }

+

+    return ccdb;

+}

+

+struct kcm_ccdb_nextid_state {

+    char *next_cc;

+    struct kcm_ccdb *db;

+    struct cli_creds *client;

+};

+

+static void kcm_ccdb_nextid_done(struct tevent_req *subreq);

+

+struct tevent_req *kcm_ccdb_nextid_send(TALLOC_CTX *mem_ctx,

+                                        struct tevent_context *ev,

+                                        struct kcm_ccdb *db,

+                                        struct cli_creds *client)

+{

+    struct tevent_req *req = NULL;

+    struct tevent_req *subreq = NULL;

+    struct kcm_ccdb_nextid_state *state = NULL;

+    errno_t ret;

+

+    req = tevent_req_create(mem_ctx, &state, struct kcm_ccdb_nextid_state);

+    if (req == NULL) {

+        return NULL;

+    }

+    state->db = db;

+    state->client = client;

+

+    if (ev == NULL || db == NULL || client == NULL) {

+        ret = EINVAL;

+        goto immediate;

+    }

+

+    subreq = state->db->ops->nextid_send(mem_ctx, ev, state->db, client);

+    if (subreq == NULL) {

+        ret = ENOMEM;

+        goto immediate;

+    }

+    tevent_req_set_callback(subreq, kcm_ccdb_nextid_done, req);

+    return req;

+

+immediate:

+    tevent_req_error(req, ret);

+    tevent_req_post(req, ev);

+    return req;

+}

+

+static void kcm_ccdb_nextid_done(struct tevent_req *subreq)

+{

+    struct tevent_req *req = tevent_req_callback_data(subreq,

+                                                      struct tevent_req);

+    struct kcm_ccdb_nextid_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_nextid_state);

+    errno_t ret;

+    unsigned int nextid;

+

+    ret = state->db->ops->nextid_recv(subreq, &nextid);

+    talloc_zfree(subreq);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_OP_FAILURE,

+              "Failed to generate next UID [%d]: %s\n",

+              ret, sss_strerror(ret));

+        tevent_req_error(req, ret);

+        return;

+    }

+

+    state->next_cc = talloc_asprintf(state, "%"SPRIuid":%u",

+                                     cli_creds_get_uid(state->client),

+                                     nextid);

+    if (state->next_cc == NULL) {

+        DEBUG(SSSDBG_CRIT_FAILURE, "talloc_asprintf failed\n");

+        tevent_req_error(req, ENOMEM);

+        return;

+    }

+

+    DEBUG(SSSDBG_TRACE_LIBS, "generated %s\n", state->next_cc);

+    tevent_req_done(req);

+}

+

+errno_t kcm_ccdb_nextid_recv(struct tevent_req *req,

+                             TALLOC_CTX *mem_ctx,

+                             char **_next_cc)

+{

+    struct kcm_ccdb_nextid_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_nextid_state);

+    TEVENT_REQ_RETURN_ON_ERROR(req);

+    *_next_cc = talloc_steal(mem_ctx, state->next_cc);

+    return EOK;

+}

+

+struct kcm_ccdb_list_state {

+    struct kcm_ccdb *db;

+    struct cli_creds *client;

+

+    uuid_t *uuid_list;

+};

+

+static void kcm_ccdb_list_done(struct tevent_req *subreq);

+

+struct tevent_req *kcm_ccdb_list_send(TALLOC_CTX *mem_ctx,

+                                      struct tevent_context *ev,

+                                      struct kcm_ccdb *db,

+                                      struct cli_creds *client)

+{

+    struct tevent_req *req = NULL;

+    struct tevent_req *subreq = NULL;

+    struct kcm_ccdb_list_state *state = NULL;

+    errno_t ret;

+

+    req = tevent_req_create(mem_ctx, &state, struct kcm_ccdb_list_state);

+    if (req == NULL) {

+        return NULL;

+    }

+    state->db = db;

+    state->client = client;

+

+    if (ev == NULL || db == NULL || client == NULL) {

+        ret = EINVAL;

+        goto immediate;

+    }

+

+    subreq = state->db->ops->list_send(mem_ctx,

+                                       ev,

+                                       state->db,

+                                       client);

+    if (subreq == NULL) {

+        ret = ENOMEM;

+        goto immediate;

+    }

+    tevent_req_set_callback(subreq, kcm_ccdb_list_done, req);

+    return req;

+

+immediate:

+    tevent_req_error(req, ret);

+    tevent_req_post(req, ev);

+    return req;

+}

+

+static void kcm_ccdb_list_done(struct tevent_req *subreq)

+{

+    struct tevent_req *req = tevent_req_callback_data(subreq,

+                                                      struct tevent_req);

+    struct kcm_ccdb_list_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_list_state);

+    errno_t ret;

+

+    ret = state->db->ops->list_recv(subreq, state, &state->uuid_list);

+    talloc_zfree(subreq);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_OP_FAILURE,

+              "Failed to list all ccaches [%d]: %s\n",

+              ret, sss_strerror(ret));

+        tevent_req_error(req, ret);

+        return;

+    }

+

+    tevent_req_done(req);

+}

+

+errno_t kcm_ccdb_list_recv(struct tevent_req *req,

+                           TALLOC_CTX *mem_ctx,

+                           uuid_t **_uuid_list)

+{

+    struct kcm_ccdb_list_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_list_state);

+    TEVENT_REQ_RETURN_ON_ERROR(req);

+    *_uuid_list = talloc_steal(mem_ctx, state->uuid_list);

+    return EOK;

+}

+

+struct kcm_ccdb_get_default_state {

+    struct kcm_ccdb *db;

+    uuid_t uuid;

+};

+

+static void kcm_ccdb_get_default_done(struct tevent_req *subreq);

+

+struct tevent_req *kcm_ccdb_get_default_send(TALLOC_CTX *mem_ctx,

+                                             struct tevent_context *ev,

+                                             struct kcm_ccdb *db,

+                                             struct cli_creds *client)

+{

+    struct tevent_req *req = NULL;

+    struct tevent_req *subreq = NULL;

+    struct kcm_ccdb_get_default_state *state = NULL;

+    errno_t ret;

+

+    req = tevent_req_create(mem_ctx, &state, struct kcm_ccdb_get_default_state);

+    if (req == NULL) {

+        return NULL;

+    }

+    state->db = db;

+

+    if (ev == NULL || db == NULL || client == NULL) {

+        ret = EINVAL;

+        goto immediate;

+    }

+

+    subreq = db->ops->get_default_send(mem_ctx, ev, db, client);

+    if (subreq == NULL) {

+        ret = ENOMEM;

+        goto immediate;

+    }

+    tevent_req_set_callback(subreq, kcm_ccdb_get_default_done, req);

+    return req;

+

+immediate:

+    tevent_req_error(req, ret);

+    tevent_req_post(req, ev);

+    return req;

+}

+

+static void kcm_ccdb_get_default_done(struct tevent_req *subreq)

+{

+    struct tevent_req *req = tevent_req_callback_data(subreq,

+                                                      struct tevent_req);

+    struct kcm_ccdb_get_default_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_get_default_state);

+    errno_t ret;

+

+    ret = state->db->ops->get_default_recv(subreq, state->uuid);

+    talloc_zfree(subreq);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_OP_FAILURE,

+              "Failed to get the default ccache [%d]: %s\n",

+              ret, sss_strerror(ret));

+        tevent_req_error(req, ret);

+        return;

+    }

+

+    tevent_req_done(req);

+}

+

+errno_t kcm_ccdb_get_default_recv(struct tevent_req *req,

+                                  uuid_t *uuid)

+{

+    struct kcm_ccdb_get_default_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_get_default_state);

+    TEVENT_REQ_RETURN_ON_ERROR(req);

+

+    if (uuid != NULL) {

+        /* The caller might supply a NULL dfl to just check if there is

+         * some default ccache

+         */

+        uuid_copy(*uuid, state->uuid);

+    }

+

+    return EOK;

+}

+

+struct kcm_ccdb_set_default_state {

+    struct tevent_context *ev;

+    struct kcm_ccdb *db;

+    struct cli_creds *client;

+    uuid_t uuid;

+};

+

+static void kcm_ccdb_set_default_uuid_resolved(struct tevent_req *subreq);

+static void kcm_ccdb_set_default_done(struct tevent_req *subreq);

+

+struct tevent_req *kcm_ccdb_set_default_send(TALLOC_CTX *mem_ctx,

+                                             struct tevent_context *ev,

+                                             struct kcm_ccdb *db,

+                                             struct cli_creds *client,

+                                             uuid_t uuid)

+{

+    struct tevent_req *req = NULL;

+    struct tevent_req *subreq = NULL;

+    struct kcm_ccdb_set_default_state *state = NULL;

+    errno_t ret;

+

+    req = tevent_req_create(mem_ctx, &state, struct kcm_ccdb_set_default_state);

+    if (req == NULL) {

+        return NULL;

+    }

+    state->db = db;

+    state->ev = ev;

+    state->client = client;

+    uuid_copy(state->uuid, uuid);

+

+    if (ev == NULL || db == NULL || client == NULL) {

+        ret = EINVAL;

+        goto immediate;

+    }

+

+    if (uuid_is_null(uuid)) {

+        /* NULL UUID means to just reset the default to 'no default' */

+        subreq = state->db->ops->set_default_send(state,

+                                                state->ev,

+                                                state->db,

+                                                state->client,

+                                                state->uuid);

+        if (subreq == NULL) {

+            ret = ENOMEM;

+            goto immediate;

+        }

+        tevent_req_set_callback(subreq, kcm_ccdb_set_default_done, req);

+    } else {

+        /* Otherwise we need to check if the client can access the UUID

+         * about to be set as default

+         */

+        subreq = db->ops->getbyuuid_send(state, ev, db, client, uuid);

+        if (subreq == NULL) {

+            ret = ENOMEM;

+            goto immediate;

+        }

+        tevent_req_set_callback(subreq, kcm_ccdb_set_default_uuid_resolved, req);

+    }

+

+    return req;

+

+immediate:

+    tevent_req_error(req, ret);

+    tevent_req_post(req, ev);

+    return req;

+}

+

+static void kcm_ccdb_set_default_uuid_resolved(struct tevent_req *subreq)

+{

+    struct tevent_req *req = tevent_req_callback_data(subreq,

+                                                      struct tevent_req);

+    struct kcm_ccdb_set_default_state *state = tevent_req_data(req,

+                                                struct kcm_ccdb_set_default_state);

+    errno_t ret;

+    bool ok;

+    struct kcm_ccache *cc;

+

+    ret = state->db->ops->getbyuuid_recv(subreq, state, &cc);