6584N/A

6584N/A#include <errno.h>

6584N/A#include <tevent.h>

6584N/A

6584N/A#include "providers/ldap/ldap_common.h"

6584N/A#include "providers/ldap/sdap_autofs.h"

6584N/A#include "providers/ldap/sdap.h"

6584N/A#include "providers/ldap/sdap_async.h"

6584N/A#include "providers/dp_backend.h"

6584N/A#include "providers/data_provider.h"

6584N/A#include "db/sysdb_autofs.h"

6584N/A#include "util/util.h"

6584N/A

6584N/Astatic void

6584N/Asdap_autofs_shutdown(struct be_req *req)

6584N/A{

6584N/A sdap_handler_done(req, DP_ERR_OK, EOK, NULL);

6584N/A}

6584N/A

7291N/Avoid sdap_autofs_handler(struct be_req *be_req);

6584N/A

6584N/Astruct bet_ops sdap_autofs_ops = {

6584N/A .handler = sdap_autofs_handler,

6584N/A .finalize = sdap_autofs_shutdown

6584N/A};

6584N/A

6584N/Aint sdap_autofs_init(struct be_ctx *be_ctx,

6584N/A struct sdap_id_ctx *id_ctx,

6584N/A struct bet_ops **ops,

6584N/A void **pvt_data)

6584N/A{

6584N/A int ret;

6584N/A

6584N/A DEBUG(SSSDBG_TRACE_INTERNAL, ("Initializing autofs LDAP back end\n"));

6584N/A

6584N/A *ops = &sdap_autofs_ops;

6584N/A *pvt_data = id_ctx;

6584N/A

6584N/A ret = ldap_get_autofs_options(id_ctx, be_ctx->cdb,

6584N/A be_ctx->conf_path, id_ctx->opts);

6584N/A if (ret != EOK) {

6584N/A return ret;

6584N/A }

6584N/A

6584N/A return ret;

6584N/A}

7291N/A

6584N/Astatic struct tevent_req *

6584N/Asdap_autofs_get_map_send(TALLOC_CTX *mem_ctx,

6584N/A struct tevent_context *ev,

6584N/A struct sdap_id_ctx *ctx,

6584N/A const char *map_name);

6584N/A

6584N/Astatic void sdap_autofs_handler_done(struct tevent_req *req);

6584N/A

6584N/Avoid sdap_autofs_handler(struct be_req *be_req)

6584N/A{

6584N/A struct be_ctx *be_ctx = be_req_get_be_ctx(be_req);

6584N/A struct sdap_id_ctx *id_ctx;

6584N/A struct be_autofs_req *autofs_req;

6584N/A struct tevent_req *req;

6584N/A const char *master_map;

6584N/A int ret = EOK;

6584N/A

6584N/A DEBUG(SSSDBG_TRACE_INTERNAL, ("sdap autofs handler called\n"));

id_ctx = talloc_get_type(be_ctx->bet_info[BET_AUTOFS].pvt_bet_data,

struct sdap_id_ctx);

if (be_is_offline(id_ctx->be)) {

return sdap_handler_done(be_req, DP_ERR_OFFLINE, EAGAIN, "Offline");

}

autofs_req = talloc_get_type(be_req_get_data(be_req), struct be_autofs_req);

DEBUG(SSSDBG_FUNC_DATA, ("Requested refresh for: %s\n",

autofs_req->mapname ? autofs_req->mapname : "<ALL>\n"));

if (autofs_req->mapname != NULL) {

master_map = dp_opt_get_string(id_ctx->opts->basic,

SDAP_AUTOFS_MAP_MASTER_NAME);

if (strcmp(master_map, autofs_req->mapname) == 0) {

autofs_req->invalidate = true;

DEBUG(SSSDBG_FUNC_DATA, ("Refresh of automount master map triggered: %s\n",

autofs_req->mapname));

}

}

if (autofs_req->invalidate) {

ret = sysdb_invalidate_autofs_maps(id_ctx->be->domain);

if (ret != EOK) {

DEBUG(SSSDBG_MINOR_FAILURE, ("Could not invalidate autofs maps, "

"backend might return stale entries\n"));

}

}

req = sdap_autofs_get_map_send(be_req, be_ctx->ev,

id_ctx, autofs_req->mapname);

if (!req) {

ret = ENOMEM;

goto fail;

}

tevent_req_set_callback(req, sdap_autofs_handler_done, be_req);

return;

fail:

be_req_terminate(be_req, DP_ERR_FATAL, ret, NULL);

}

struct autofs_get_map_state {

struct tevent_context *ev;

struct sdap_id_ctx *ctx;

struct sdap_id_op *op;

const char *map_name;

int dp_error;

};

static errno_t

sdap_autofs_get_map_retry(struct tevent_req *req);

static void

sdap_autofs_get_map_connect_done(struct tevent_req *subreq);

static void

sdap_autofs_get_map_done(struct tevent_req *req);

static struct tevent_req *

sdap_autofs_get_map_send(TALLOC_CTX *mem_ctx,

struct tevent_context *ev,

struct sdap_id_ctx *ctx,

const char *map_name)

{

struct tevent_req *req;

struct autofs_get_map_state *state;

int ret;

req = tevent_req_create(mem_ctx, &state, struct autofs_get_map_state);

if (!req) return NULL;

state->ev = ev;

state->ctx = ctx;

state->dp_error = DP_ERR_FATAL;

state->map_name = map_name;

state->op = sdap_id_op_create(state, state->ctx->conn->conn_cache);

if (!state->op) {

DEBUG(SSSDBG_OP_FAILURE, ("sdap_id_op_create failed\n"));

ret = ENOMEM;

goto fail;

}

ret = sdap_autofs_get_map_retry(req);

if (ret != EOK) {

goto fail;

}

return req;

fail:

tevent_req_error(req, ret);

tevent_req_post(req, ev);

return req;

}

static errno_t

sdap_autofs_get_map_retry(struct tevent_req *req)

{

struct autofs_get_map_state *state =

tevent_req_data(req, struct autofs_get_map_state);

struct tevent_req *subreq;

int ret = EOK;

subreq = sdap_id_op_connect_send(state->op, state, &ret);

if (!subreq) {

return ret;

}

tevent_req_set_callback(subreq, sdap_autofs_get_map_connect_done, req);

return EOK;

}

static void

sdap_autofs_get_map_connect_done(struct tevent_req *subreq)

{

struct tevent_req *req = tevent_req_callback_data(subreq,

struct tevent_req);

struct autofs_get_map_state *state =

tevent_req_data(req, struct autofs_get_map_state);

int dp_error = DP_ERR_FATAL;

int ret;

ret = sdap_id_op_connect_recv(subreq, &dp_error);

talloc_zfree(subreq);

if (ret != EOK) {

state->dp_error = dp_error;

tevent_req_error(req, ret);

return;

}

subreq = sdap_autofs_setautomntent_send(state, state->ev,

state->ctx->be->domain,

state->ctx->be->domain->sysdb,

sdap_id_op_handle(state->op),

state->op,

state->ctx->opts,

state->map_name);

if (!subreq) {

DEBUG(SSSDBG_CRIT_FAILURE,

("sdap_autofs_setautomntent_send failed\n"));

tevent_req_error(req, ENOMEM);

return;

}

tevent_req_set_callback(subreq, sdap_autofs_get_map_done, req);

}

static void

sdap_autofs_get_map_done(struct tevent_req *subreq)

{

struct tevent_req *req = tevent_req_callback_data(subreq,

struct tevent_req);

struct autofs_get_map_state *state =

tevent_req_data(req, struct autofs_get_map_state);

int dp_error = DP_ERR_FATAL;

int ret;

ret = sdap_autofs_setautomntent_recv(subreq);

talloc_zfree(subreq);

ret = sdap_id_op_done(state->op, ret, &dp_error);

if (dp_error == DP_ERR_OK && ret != EOK) {

/* retry */

ret = sdap_autofs_get_map_retry(req);

if (ret != EOK) {

tevent_req_error(req, ret);

return;

}

return;

}

if (ret && ret != ENOENT) {

state->dp_error = dp_error;

tevent_req_error(req, ret);

return;

}

if (ret == ENOENT) {

ret = sysdb_delete_autofsmap(state->ctx->be->domain, state->map_name);

if (ret != EOK && ret != ENOENT) {

DEBUG(SSSDBG_OP_FAILURE,

("Cannot delete autofs map %s [%d]: %s\n",

state->map_name, ret, strerror(ret)));

tevent_req_error(req, ret);

return;

}

}

state->dp_error = DP_ERR_OK;

tevent_req_done(req);

}

static errno_t

sdap_autofs_get_map_recv(struct tevent_req *req, int *dp_error_out)

{

struct autofs_get_map_state *state =

tevent_req_data(req, struct autofs_get_map_state);

if (dp_error_out) {

*dp_error_out = state->dp_error;

}

TEVENT_REQ_RETURN_ON_ERROR(req);

return EOK;

}

static void

sdap_autofs_handler_done(struct tevent_req *req)

{

struct be_req *be_req =

tevent_req_callback_data(req, struct be_req);

int dperr;

errno_t ret;

ret = sdap_autofs_get_map_recv(req, &dperr);

sdap_handler_done(be_req, dperr, ret, strerror(ret));

}