From b0043a95f86b240d0beb551ef4e9ff9a4be99995 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina@redhat.com>

Date: Wed, 7 Aug 2019 13:59:04 +0200

Subject: [PATCH 78/90] autofs: convert code to cache_req

MIME-Version: 1.0

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

Content-Transfer-Encoding: 8bit

This will simplify the code a lot so it can be further extended.

At this point the conversion is done 1:1, we will do additional

changes in next patches.

Resolves:

https://pagure.io/SSSD/sssd/issue/2607

Reviewed-by: Tomáš Halman <thalman@redhat.com>

---

 src/responder/autofs/autofs_private.h |   72 +-

 src/responder/autofs/autofssrv.c      |    7 +-

 src/responder/autofs/autofssrv_cmd.c  | 1651 ++++++++-----------------

 3 files changed, 549 insertions(+), 1181 deletions(-)

diff --git a/src/responder/autofs/autofs_private.h b/src/responder/autofs/autofs_private.h

index 6a39b17ad..3be25d4d9 100644

--- a/src/responder/autofs/autofs_private.h

+++ b/src/responder/autofs/autofs_private.h

@@ -21,7 +21,9 @@

 #ifndef _AUTOFSSRV_PRIVATE_H_

 #define _AUTOFSSRV_PRIVATE_H_

+#include "responder/common/responder.h"

 #include "responder/common/responder_sbus.h"

+#include "responder/common/cache_req/cache_req.h"

 #define SSS_AUTOFS_PROTO_VERSION        0x001

@@ -33,75 +35,33 @@ struct autofs_ctx {

     hash_table_t *maps;

 };

-struct autofs_state_ctx {

-    char *automntmap_name;

-};

-

 struct autofs_cmd_ctx {

-    struct cli_ctx *cctx;

-    char *mapname;

-    char *key;

-    uint32_t cursor;

+    struct autofs_ctx *autofs_ctx;

+    struct cli_ctx *cli_ctx;

+

+    const char *mapname;

+    const char *keyname;

     uint32_t max_entries;

-    bool check_next;

+    uint32_t cursor;

 };

-struct autofs_dom_ctx {

-    struct autofs_cmd_ctx  *cmd_ctx;

-    struct sss_domain_info *domain;

-    bool check_provider;

-

-    /* cache results */

-    struct ldb_message *map;

-

-    size_t entry_count;

-    struct ldb_message **entries;

-

-    struct autofs_map_ctx *map_ctx;

-};

+struct autofs_enum_ctx {

+    /* Results. First result is the map objects, next results are map entries. */

+    struct cache_req_result *result;

-struct autofs_map_ctx {

-    /* state of the map entry */

-    bool ready;

+    /* True if the map was found. */

     bool found;

-    /* requests */

-    struct setent_req_list *reqs;

-

-    hash_table_t *map_table;

-    char *mapname;

+    /* False if the result is being created. */

+    bool ready;

-    /* map entry */

-    struct ldb_message *map;

-    size_t entry_count;

-    struct ldb_message **entries;

+    /* Requests that awaits the data. */

+    struct setent_req_list *notify_list;

 };

 struct sss_cmd_table *get_autofs_cmds(void);

 int autofs_connection_setup(struct cli_ctx *cctx);

-void autofs_map_hash_delete_cb(hash_entry_t *item,

-                               hash_destroy_enum deltype, void *pvt);

-

 errno_t autofs_orphan_maps(struct autofs_ctx *actx);

-enum sss_dp_autofs_type {

-    SSS_DP_AUTOFS

-};

-

-struct tevent_req *

-sss_dp_get_autofs_send(TALLOC_CTX *mem_ctx,

-                       struct resp_ctx *rctx,

-                       struct sss_domain_info *dom,

-                       bool fast_reply,

-                       enum sss_dp_autofs_type type,

-                       const char *name);

-

-errno_t

-sss_dp_get_autofs_recv(TALLOC_CTX *mem_ctx,

-                       struct tevent_req *req,

-                       dbus_uint16_t *dp_err,

-                       dbus_uint32_t *dp_ret,

-                       char **err_msg);

-

 #endif /* _AUTOFSSRV_PRIVATE_H_ */

diff --git a/src/responder/autofs/autofssrv.c b/src/responder/autofs/autofssrv.c

index 7d236f4d9..309ed76b1 100644

--- a/src/responder/autofs/autofssrv.c

+++ b/src/responder/autofs/autofssrv.c

@@ -28,6 +28,7 @@

 #include "responder/common/responder.h"

 #include "providers/data_provider.h"

 #include "responder/autofs/autofs_private.h"

+#include "util/sss_ptr_hash.h"

 static int autofs_clean_hash_table(struct sbus_request *dbus_req, void *data);

@@ -105,7 +106,6 @@ autofs_process_init(TALLOC_CTX *mem_ctx,

     struct autofs_ctx *autofs_ctx;

     struct be_conn *iter;

     int ret;

-    int hret;

     int max_retries;

     autofs_cmds = get_autofs_cmds();

@@ -158,9 +158,8 @@ autofs_process_init(TALLOC_CTX *mem_ctx,

     }

     /* Create the lookup table for setautomntent results */

-    hret = sss_hash_create_ex(autofs_ctx, 10, &autofs_ctx->maps, 0, 0, 0, 0,

-                              autofs_map_hash_delete_cb, NULL);

-    if (hret != HASH_SUCCESS) {

+    autofs_ctx->maps = sss_ptr_hash_create(autofs_ctx, NULL, NULL);

+    if (autofs_ctx->maps == NULL) {

         DEBUG(SSSDBG_CRIT_FAILURE,

               "Unable to initialize automount maps hash table\n");

         ret = EIO;

diff --git a/src/responder/autofs/autofssrv_cmd.c b/src/responder/autofs/autofssrv_cmd.c

index 9ea2ab71b..670b6d50d 100644

--- a/src/responder/autofs/autofssrv_cmd.c

+++ b/src/responder/autofs/autofssrv_cmd.c

@@ -25,20 +25,22 @@

 #include "util/util.h"

 #include "responder/common/responder.h"

 #include "responder/common/responder_packet.h"

+#include "responder/common/cache_req/cache_req.h"

 #include "responder/autofs/autofs_private.h"

 #include "db/sysdb.h"

 #include "db/sysdb_autofs.h"

 #include "confdb/confdb.h"

+#include "util/sss_ptr_hash.h"

 static int autofs_cmd_send_error(struct autofs_cmd_ctx *cmdctx, int err)

 {

-    return sss_cmd_send_error(cmdctx->cctx, err);

+    return sss_cmd_send_error(cmdctx->cli_ctx, err);

 }

 static int

 autofs_cmd_send_empty(struct autofs_cmd_ctx *cmdctx)

 {

-    return sss_cmd_send_empty(cmdctx->cctx);

+    return sss_cmd_send_empty(cmdctx->cli_ctx);

 }

 static int

@@ -54,7 +56,7 @@ autofs_cmd_done(struct autofs_cmd_ctx *cmdctx, int ret)

         if (ret) {

             return EFAULT;

         }

-        sss_cmd_done(cmdctx->cctx, cmdctx);

+        sss_cmd_done(cmdctx->cli_ctx, cmdctx);

         break;

     case EAGAIN:

@@ -70,7 +72,7 @@ autofs_cmd_done(struct autofs_cmd_ctx *cmdctx, int ret)

         if (ret) {

             return EFAULT;

         }

-        sss_cmd_done(cmdctx->cctx, cmdctx);

+        sss_cmd_done(cmdctx->cli_ctx, cmdctx);

         break;

     }

@@ -78,1058 +80,524 @@ autofs_cmd_done(struct autofs_cmd_ctx *cmdctx, int ret)

 }

 static errno_t

-autofs_setent_add_ref(TALLOC_CTX *memctx,

-                      struct autofs_map_ctx *map_ctx,

-                      struct tevent_req *req)

+autofs_fill_entry(struct ldb_message *entry, struct sss_packet *packet, size_t *rp)

 {

-    return setent_add_ref(memctx, &map_ctx->reqs, req);

-}

-

-static void

-autofs_setent_notify(struct autofs_map_ctx *map_ctx, errno_t ret)

-{

-    setent_notify(&map_ctx->reqs, ret);

-}

-

-errno_t

-autofs_orphan_maps(struct autofs_ctx *actx)

-{

-    int hret;

-    unsigned long mcount;

-    unsigned long i;

-    hash_key_t *maps;

+    errno_t ret;

+    const char *key;

+    size_t keylen;

+    const char *value;

+    size_t valuelen;

+    uint8_t *body;

+    size_t blen;

+    size_t len;

-    if (!actx || !actx->maps) {

+    key = ldb_msg_find_attr_as_string(entry, SYSDB_AUTOFS_ENTRY_KEY, NULL);

+    value = ldb_msg_find_attr_as_string(entry, SYSDB_AUTOFS_ENTRY_VALUE, NULL);

+    if (!key || !value) {

+        DEBUG(SSSDBG_MINOR_FAILURE, "Incomplete entry\n");

         return EINVAL;

     }

-    hret = hash_keys(actx->maps, &mcount, &maps);

-    if (hret != HASH_SUCCESS) {

-        return EIO;

-    }

-

-    for (i = 0; i < mcount; i++) {

-        hret = hash_delete(actx->maps, &maps[i]);

-        if (hret != HASH_SUCCESS) {

-            DEBUG(SSSDBG_MINOR_FAILURE, "Could not delete key from hash\n");

-            continue;

-        }

-    }

-

-    return EOK;

-}

+    keylen = 1 + strlen(key);

+    valuelen = 1 + strlen(value);

+    len = sizeof(uint32_t) + sizeof(uint32_t) + keylen + sizeof(uint32_t) + valuelen;

-static errno_t

-get_autofs_map(struct autofs_ctx *actx,

-               char *mapname,

-               struct autofs_map_ctx **map)

-{

-    hash_key_t key;

-    hash_value_t value;

-    int hret;

-

-    key.type = HASH_KEY_STRING;

-    key.str = mapname;

-

-    hret = hash_lookup(actx->maps, &key, &value);

-    if (hret == HASH_SUCCESS) {

-        *map = talloc_get_type(value.ptr, struct autofs_map_ctx);

-        return EOK;

-    } else if (hret == HASH_ERROR_KEY_NOT_FOUND) {

-        return ENOENT;

+    ret = sss_packet_grow(packet, len);

+    if (ret != EOK) {

+        DEBUG(SSSDBG_OP_FAILURE, "Cannot grow packet\n");

+        return ret;

     }

-    DEBUG(SSSDBG_CRIT_FAILURE,

-          "Unexpected error reading from autofs map hash [%d][%s]\n",

-          hret, hash_error_string(hret));

-    return EIO;

-}

-

-static int autofs_map_hash_remove (TALLOC_CTX *ctx);

+    sss_packet_get_body(packet, &body, &blen);

-void

-autofs_map_hash_delete_cb(hash_entry_t *item,

-                          hash_destroy_enum deltype, void *pvt)

-{

-    struct autofs_map_ctx *map;

+    SAFEALIGN_SET_UINT32(&body[*rp], len, rp);

+    SAFEALIGN_SET_UINT32(&body[*rp], keylen, rp);

-    if (deltype != HASH_ENTRY_DESTROY) {

-        return;

+    if (keylen == 1) {

+        body[*rp] = '\0';

+    } else {

+        memcpy(&body[*rp], key, keylen);

     }

+    *rp += keylen;

-    map = talloc_get_type(item->value.ptr, struct autofs_map_ctx);

-    if (!map) {

-        DEBUG(SSSDBG_OP_FAILURE, "Invalid autofs map\n");

-        return;

+    SAFEALIGN_SET_UINT32(&body[*rp], valuelen, rp);

+    if (valuelen == 1) {

+        body[*rp] = '\0';

+    } else {

+        memcpy(&body[*rp], value, valuelen);

     }

+    *rp += valuelen;

-    /* So that the destructor wouldn't attempt to remove the map from hash

-     * table */

-    map->map_table = NULL;

+    return EOK;

 }

-static errno_t

-set_autofs_map(struct autofs_ctx *actx,

-               struct autofs_map_ctx *map)

+errno_t

+autofs_orphan_maps(struct autofs_ctx *autofs_ctx)

 {

-    hash_key_t key;

-    hash_value_t value;

-    int hret;

-

-    if (map->mapname == NULL) {

-        DEBUG(SSSDBG_CRIT_FAILURE, "Missing autofs map name.\n");

-        return EINVAL;

-    }

-

-    /* Add this entry to the hash table */

-    key.type = HASH_KEY_STRING;

-    key.str = map->mapname;

-    value.type = HASH_VALUE_PTR;

-    value.ptr = map;

-    hret = hash_enter(actx->maps, &key, &value);

-    if (hret != EOK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Unable to add hash table entry for [%s]\n", key.str);

-        DEBUG(SSSDBG_MINOR_FAILURE,

-              "Hash error [%d][%s]\n", hret, hash_error_string(hret));

-        return EIO;

-    }

-    talloc_steal(actx->maps, map);

-    talloc_set_destructor((TALLOC_CTX *) map, autofs_map_hash_remove);

+    sss_ptr_hash_delete_all(autofs_ctx->maps, true);

     return EOK;

 }

-static int

-autofs_map_hash_remove(TALLOC_CTX *ctx)

+static void

+autofs_enumctx_lifetime_timeout(struct tevent_context *ev,

+                                struct tevent_timer *te,

+                                struct timeval current_time,

+                                void *pvt)

 {

-    int hret;

-    hash_key_t key;

-    struct autofs_map_ctx *map =

-            talloc_get_type(ctx, struct autofs_map_ctx);

-

-    if (map->map_table == NULL) {

-        DEBUG(SSSDBG_TRACE_LIBS, "autofs map [%s] was already removed\n",

-              map->mapname);

-        return 0;

-    }

+    struct autofs_enum_ctx *enum_ctx;

-    key.type = HASH_KEY_STRING;

-    key.str = map->mapname;

+    enum_ctx = talloc_get_type(pvt, struct autofs_enum_ctx);

-    /* Remove the autofs map result object from the lookup table */

-    hret = hash_delete(map->map_table, &key);

-    if (hret != HASH_SUCCESS) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Could not remove key from table! [%d][%s]\n",

-              hret, hash_error_string(hret));

-        return -1;

-    }

-    return 0;

+    /* Free the context. It will be automatically removed from the hash table. */

+    talloc_free(enum_ctx);

 }

-static struct tevent_req *

-setautomntent_send(TALLOC_CTX *mem_ctx,

-                   const char *rawname,

-                   struct autofs_cmd_ctx *cmdctx);

-static errno_t setautomntent_recv(struct tevent_req *req);

-static void sss_autofs_cmd_setautomntent_done(struct tevent_req *req);

-

-/* FIXME - file a ticket to have per-responder private

- * data instead of growing the cli_ctx structure */

-static int

-sss_autofs_cmd_setautomntent(struct cli_ctx *client)

+static void

+autofs_set_enumctx_lifetime(struct autofs_ctx *autofs_ctx,

+                            struct autofs_enum_ctx *enum_ctx,

+                            uint32_t lifetime)

 {

-    struct autofs_cmd_ctx *cmdctx;

-    struct cli_protocol *pctx;

-    uint8_t *body;

-    size_t blen;

-    errno_t ret = EOK;

-    const char *rawname;

-    struct tevent_req *req;

-

-    DEBUG(SSSDBG_TRACE_INTERNAL, "sss_autofs_cmd_setautomntent\n");

-

-    cmdctx = talloc_zero(client, struct autofs_cmd_ctx);

-    if (!cmdctx) {

-        return ENOMEM;

-    }

-    cmdctx->cctx = client;

-

-    pctx = talloc_get_type(cmdctx->cctx->protocol_ctx, struct cli_protocol);

-

-    sss_packet_get_body(pctx->creq->in, &body, &blen);

-

-    /* if not terminated fail */

-    if (body[blen -1] != '\0') {

-        ret = EINVAL;

-        goto done;

-    }

-

-    /* If the body isn't valid UTF-8, fail */

-    if (!sss_utf8_check(body, blen -1)) {

-        ret = EINVAL;

-        goto done;

-    }

-

-    rawname = (const char *)body;

-    DEBUG(SSSDBG_TRACE_FUNC,

-          "Got request for automount map named %s\n", rawname);

+    struct timeval tv;

+    struct tevent_timer *te;

-    req = setautomntent_send(cmdctx, rawname, cmdctx);

-    if (!req) {

+    tv = tevent_timeval_current_ofs(lifetime, 0);

+    te = tevent_add_timer(autofs_ctx->rctx->ev, enum_ctx, tv,

+                          autofs_enumctx_lifetime_timeout, enum_ctx);

+    if (te == NULL) {

         DEBUG(SSSDBG_CRIT_FAILURE,

-              "Fatal error calling setautomntent_send\n");

-        ret = EIO;

-        goto done;

+              "Could not set up life timer for autofs maps. "

+              "Entries may become stale.\n");

     }

-    tevent_req_set_callback(req, sss_autofs_cmd_setautomntent_done, cmdctx);

-

-    ret = EOK;

-done:

-    return autofs_cmd_done(cmdctx, ret);

 }

-static void sss_autofs_cmd_setautomntent_done(struct tevent_req *req)

+static struct autofs_enum_ctx *

+autofs_create_enumeration_context(TALLOC_CTX *mem_ctx,

+                                  struct autofs_ctx *autofs_ctx,

+                                  const char *mapname)

 {

-    struct autofs_cmd_ctx *cmdctx =

-        tevent_req_callback_data(req, struct autofs_cmd_ctx);

-    struct cli_protocol *pctx;

+    struct autofs_enum_ctx *enum_ctx;

     errno_t ret;

-    errno_t reqret;

-    uint8_t *body;

-    size_t blen;

-    DEBUG(SSSDBG_TRACE_INTERNAL, "setautomntent done\n");

-

-    reqret = setautomntent_recv(req);

-    talloc_zfree(req);

-    if (reqret != EOK && reqret != ENOENT) {

-        DEBUG(SSSDBG_CRIT_FAILURE, "setautomntent_recv failed\n");

-        autofs_cmd_done(cmdctx, reqret);

-        return;

+    enum_ctx = talloc_zero(mem_ctx, struct autofs_enum_ctx);

+    if (enum_ctx == NULL) {

+        return NULL;

     }

-    pctx = talloc_get_type(cmdctx->cctx->protocol_ctx, struct cli_protocol);

+    enum_ctx->ready = false;

-    /* Either we succeeded or no domains were eligible */

-    ret = sss_packet_new(pctx->creq, 0,

-                         sss_packet_get_cmd(pctx->creq->in),

-                         &pctx->creq->out);

-    if (ret == EOK) {

-        if (reqret == ENOENT) {

-            DEBUG(SSSDBG_TRACE_FUNC, "setautomntent did not find requested map\n");

-            /* Notify the caller that this entry wasn't found */

-            ret = sss_cmd_empty_packet(pctx->creq->out);

-            if (ret != EOK) {

-                DEBUG(SSSDBG_TRACE_INTERNAL,

-                      "sss_cmd_empty_packet() failed: %s [%d]\n",

-                      sss_strerror(ret), ret);

-            }

-        } else {

-            DEBUG(SSSDBG_TRACE_FUNC, "setautomntent found data\n");

-            ret = sss_packet_grow(pctx->creq->out, 2*sizeof(uint32_t));

-            if (ret != EOK) {

-                DEBUG(SSSDBG_CRIT_FAILURE, "Couldn't grow the packet\n");

-                talloc_free(cmdctx);

-                return;

-            }

-

-            sss_packet_get_body(pctx->creq->out, &body, &blen);

-

-            /* Got some results */

-            SAFEALIGN_SETMEM_UINT32(body, 1, NULL);

-

-            /* Reserved padding */

-            SAFEALIGN_SETMEM_UINT32(body + sizeof(uint32_t), 0, NULL);

-        }

-

-        sss_cmd_done(cmdctx->cctx, NULL);

-        return;

+    ret = sss_ptr_hash_add(autofs_ctx->maps, mapname,

+                           enum_ctx, struct autofs_enum_ctx);

+    if (ret != EOK) {

+        talloc_free(enum_ctx);

+        return NULL;

     }

-    DEBUG(SSSDBG_CRIT_FAILURE, "Error creating packet\n");

-    return;

+    return enum_ctx;

 }

-struct setautomntent_state {

-    struct autofs_cmd_ctx *cmdctx;

-    struct autofs_dom_ctx *dctx;

-

-    char *mapname;

-    struct autofs_map_ctx *map;

+struct autofs_setent_state {

+    struct autofs_ctx *autofs_ctx;

+    struct autofs_enum_ctx *enum_ctx;

 };

-struct setautomntent_lookup_ctx {

-    struct autofs_ctx *actx;

-    struct autofs_dom_ctx *dctx;

-    struct resp_ctx *rctx;

-    struct cli_ctx *cctx;

-

-    bool returned_to_mainloop;

-

-    char *mapname;

-    struct autofs_map_ctx *map;

-};

-

-static errno_t

-lookup_automntmap_step(struct setautomntent_lookup_ctx *lookup_ctx);

-

-static void

-autofs_map_result_timeout(struct tevent_context *ev,

-                          struct tevent_timer *te,

-                          struct timeval current_time,

-                          void *pvt)

-{

-    struct autofs_map_ctx *map =

-            talloc_get_type(pvt, struct autofs_map_ctx);

-

-    /* Free the autofs map result context

-     * The destructor for the autofs map will remove itself

-     * from the hash table

-     */

-    talloc_free(map);

-}

-

-static void

-set_autofs_map_lifetime(uint32_t lifetime,

-                        struct setautomntent_lookup_ctx *lookup_ctx,

-                        struct autofs_map_ctx *map)

-{

-    struct timeval tv;

-    struct tevent_timer *te;

-

-    tv = tevent_timeval_current_ofs(lifetime, 0);

-    te = tevent_add_timer(lookup_ctx->rctx->ev,

-                          map, tv,

-                          autofs_map_result_timeout,

-                          map);

-    if (!te) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Could not set up life timer for autofs maps. "

-               "Entries may become stale.\n");

-    }

-}

-

-static errno_t

-setautomntent_get_autofs_map(struct autofs_ctx *actx,

-                             char *mapname,

-                             struct autofs_map_ctx **map);

+static void autofs_setent_done(struct tevent_req *subreq);

 static struct tevent_req *

-setautomntent_send(TALLOC_CTX *mem_ctx,

-                   const char *rawname,

-                   struct autofs_cmd_ctx *cmdctx)

+autofs_setent_send(TALLOC_CTX *mem_ctx,

+                   struct tevent_context *ev,

+                   struct autofs_ctx *autofs_ctx,

+                   const char *mapname)

 {

-    char *domname;

-    errno_t ret;

+    struct autofs_setent_state *state;

+    struct tevent_req *subreq;

     struct tevent_req *req;

-    struct setautomntent_state *state;

-    struct cli_ctx *client = cmdctx->cctx;

-    struct autofs_dom_ctx *dctx;

-    struct autofs_ctx *actx;

-    struct autofs_state_ctx *state_ctx;

-    struct setautomntent_lookup_ctx *lookup_ctx;

-

-    actx = talloc_get_type(client->rctx->pvt_ctx, struct autofs_ctx);

-    state_ctx = talloc_get_type(client->state_ctx, struct autofs_state_ctx);

-

-    req = tevent_req_create(mem_ctx, &state, struct setautomntent_state);

-    if (!req) {

-        DEBUG(SSSDBG_FATAL_FAILURE,

-              "Could not create tevent request for setautomntent\n");

-        return NULL;

-    }

-    state->cmdctx = cmdctx;

-

-    dctx = talloc_zero(state, struct autofs_dom_ctx);

-    if (!dctx) {

-        DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory\n");

-        ret = ENOMEM;

-        goto fail;

-    }

-    dctx->cmd_ctx = state->cmdctx;

-    state->dctx = dctx;

+    errno_t ret;

-    ret = sss_parse_name_for_domains(state, client->rctx->domains,

-                                     NULL, rawname,

-                                     &domname, &state->mapname);

-    if (ret != EOK) {

-        DEBUG(SSSDBG_FATAL_FAILURE,

-              "Invalid name received [%s]\n", rawname);

-        goto fail;

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

+    if (req == NULL) {

+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");

+        return NULL;

     }

-    DEBUG(SSSDBG_TRACE_FUNC,

-         "Requesting info for automount map [%s] from [%s]\n",

-         state->mapname, domname?domname:"<ALL>");

-

-    if (domname) {

-        dctx->domain = responder_get_domain(client->rctx, domname);

-        if (!dctx->domain) {

-            ret = EINVAL;

-            goto fail;

-        }

+    state->autofs_ctx = autofs_ctx;

-        state_ctx->automntmap_name = talloc_strdup(client, rawname);

-        if (!state_ctx->automntmap_name) {

-            ret = ENOMEM;

-            goto fail;

-        }

-    } else {

-        /* this is a multidomain search */

-        dctx->domain = client->rctx->domains;

-        cmdctx->check_next = true;

-

-        state_ctx->automntmap_name = talloc_strdup(client, state->mapname);

-        if (!state_ctx->automntmap_name) {

-            ret = ENOMEM;

-            goto fail;

-        }

-    }

-

-    dctx->check_provider = NEED_CHECK_PROVIDER(dctx->domain->provider);

-    /* Is the result context already available?

-     * Check for existing lookups for this map

-     */

-    ret = setautomntent_get_autofs_map(actx, state->mapname, &state->map);

-    if (ret == EOK) {

-        /* Another process already requested this map

-         * Check whether it's ready for processing.

-         */

-        if (state->map->ready) {