>From 37a4d83070b23fefce9154480f095c55b7f4cfd0 Mon Sep 17 00:00:00 2001 From: Jakub Hrozek Date: Thu, 23 May 2013 13:03:51 +0200 Subject: [PATCH 14/15] AD ID lookups - choose GC or LDAP as appropriate https://fedorahosted.org/sssd/ticket/1557 Some lookups should be performed from GC only -- for example trusted users are only present in the Global Catalog, while some lookups should be performed from LDAP only as not all objects or attributes are replicated to Global Catalog. This patch adds a generic failover mechanism for identity lookups in the AD provider that allows to choose the appropriate source and even fail over to the other source if available. --- src/providers/ad/ad_id.c | 259 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 258 insertions(+), 1 deletion(-) diff --git a/src/providers/ad/ad_id.c b/src/providers/ad/ad_id.c index 5d8c78371a2e91fbec554a2a90d424d758ffd1a2..986f37759f9e153a13d48805a3d53d4bf454b71a 100644 --- a/src/providers/ad/ad_id.c +++ b/src/providers/ad/ad_id.c @@ -23,18 +23,275 @@ #include "providers/ad/ad_common.h" #include "providers/ad/ad_id.h" +struct ad_handle_acct_info_state { + struct be_req *breq; + struct be_acct_req *ar; + struct sdap_id_ctx *ctx; + struct sdap_id_conn_ctx **conn; + struct sdap_domain *sdom; + size_t cindex; + + int dp_error; + const char *err; +}; + +static errno_t ad_handle_acct_info_step(struct tevent_req *req); +static void ad_handle_acct_info_done(struct tevent_req *subreq); + +static struct tevent_req * +ad_handle_acct_info_send(TALLOC_CTX *mem_ctx, + struct be_req *breq, + struct be_acct_req *ar, + struct sdap_id_ctx *ctx, + struct sdap_domain *sdom, + struct sdap_id_conn_ctx **conn) +{ + struct tevent_req *req; + struct ad_handle_acct_info_state *state; + struct be_ctx *be_ctx = be_req_get_be_ctx(breq); + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct ad_handle_acct_info_state); + if (req == NULL) { + return NULL; + } + state->breq = breq; + state->ar = ar; + state->ctx = ctx; + state->sdom = sdom; + state->conn = conn; + state->cindex = 0; + + ret = ad_handle_acct_info_step(req); + if (ret == EOK) { + tevent_req_done(req); + tevent_req_post(req, be_ctx->ev); + } else if (ret != EAGAIN) { + tevent_req_error(req, ret); + tevent_req_post(req, be_ctx->ev); + } + + /* Lookup in progress */ + return req; +} + +static errno_t +ad_handle_acct_info_step(struct tevent_req *req) +{ + struct tevent_req *subreq; + struct ad_handle_acct_info_state *state = tevent_req_data(req, + struct ad_handle_acct_info_state); + bool noexist_delete = false; + + if (state->conn[state->cindex] == NULL) { + return EOK; + } + + if (state->conn[state->cindex+1] == NULL) { + noexist_delete = true; + } + + subreq = sdap_handle_acct_req_send(state, state->breq, + state->ar, state->ctx, + state->sdom, + state->conn[state->cindex], + noexist_delete); + if (req == NULL) { + return ENOMEM; + } + tevent_req_set_callback(subreq, ad_handle_acct_info_done, req); + return EAGAIN; +} + +static void +ad_handle_acct_info_done(struct tevent_req *subreq) +{ + errno_t ret; + int dp_error; + int sdap_err; + const char *err; + struct tevent_req *req = tevent_req_callback_data(subreq, + struct tevent_req); + struct ad_handle_acct_info_state *state = tevent_req_data(req, + struct ad_handle_acct_info_state); + + ret = sdap_handle_acct_req_recv(subreq, &dp_error, &err, &sdap_err); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + if (sdap_err == EOK) { + tevent_req_done(req); + return; + } else if (sdap_err != ENOENT) { + tevent_req_error(req, EIO); + return; + } + + /* Ret is only ENOENT now. Try the next connection */ + state->cindex++; + ret = ad_handle_acct_info_step(req); + if (ret != EAGAIN) { + /* No additional search in progress. Save the last + * error status, we'll be returning it. + */ + state->dp_error = dp_error; + state->err = err; + + if (ret == EOK) { + /* No more connections */ + tevent_req_done(req); + } else { + tevent_req_error(req, ret); + } + return; + } + + /* Another lookup in progress */ +} + +static errno_t +ad_handle_acct_info_recv(struct tevent_req *req, + int *_dp_error, const char **_err) +{ + struct ad_handle_acct_info_state *state = tevent_req_data(req, + struct ad_handle_acct_info_state); + + if (_dp_error) { + *_dp_error = state->dp_error; + } + + if (_err) { + *_err = state->err; + } + + TEVENT_REQ_RETURN_ON_ERROR(req); + return EOK; +} + +struct sdap_id_conn_ctx ** +get_conn_list(struct be_req *breq, struct ad_id_ctx *ad_ctx, + struct sss_domain_info *dom, struct be_acct_req *ar) +{ + struct sdap_id_conn_ctx **clist; + int i=0; + + /* LDAP, GC, sentinel */ + clist = talloc_zero_array(breq, struct sdap_id_conn_ctx *, 3); + if (clist == NULL) return NULL; + + switch (ar->entry_type & BE_REQ_TYPE_MASK) { + case BE_REQ_USER: /* user */ + case BE_REQ_GROUP: /* group */ + case BE_REQ_INITGROUPS: /* init groups for user */ + if (ad_ctx->gc_ctx && IS_SUBDOMAIN(dom)) { + clist[i] = ad_ctx->gc_ctx; + i++; + } else { + clist[i] = ad_ctx->ldap_ctx; + } + break; + + default: + clist[0] = ad_ctx->ldap_ctx; + break; + } + + return clist; +} + +static void ad_account_info_complete(struct tevent_req *req); + void ad_account_info_handler(struct be_req *be_req) { struct ad_id_ctx *ad_ctx; + struct be_acct_req *ar; struct sdap_id_ctx *sdap_id_ctx; struct be_ctx *be_ctx = be_req_get_be_ctx(be_req); + struct tevent_req *req; + struct sss_domain_info *dom; + struct sdap_domain *sdom; + struct sdap_id_conn_ctx **clist; + errno_t ret; ad_ctx = talloc_get_type(be_ctx->bet_info[BET_ID].pvt_bet_data, struct ad_id_ctx); + ar = talloc_get_type(be_req_get_data(be_req), struct be_acct_req); sdap_id_ctx = ad_ctx->sdap_id_ctx; - return sdap_handle_account_info(be_req, sdap_id_ctx, sdap_id_ctx->conn); + if (be_is_offline(be_ctx)) { + return be_req_terminate(be_req, DP_ERR_OFFLINE, EAGAIN, "Offline"); + } + + dom = be_ctx->domain; + if (strcasecmp(ar->domain, be_ctx->domain->name) != 0) { + /* Subdomain request, verify subdomain */ + dom = find_subdomain_by_name(be_ctx->domain, ar->domain, true); + } + + if (dom == NULL) { + ret = EINVAL; + goto fail; + } + + /* Determine whether to connect to GC, LDAP or try both */ + clist = get_conn_list(be_req, ad_ctx, dom, ar); + if (clist == NULL) { + ret = EIO; + goto fail; + } + + sdom = sdap_domain_get(sdap_id_ctx->opts, dom); + if (sdom == NULL) { + ret = EIO; + goto fail; + } + + req = ad_handle_acct_info_send(be_req, be_req, ar, sdap_id_ctx, + sdom, clist); + if (req == NULL) { + ret = ENOMEM; + goto fail; + } + tevent_req_set_callback(req, ad_account_info_complete, be_req); + return; + +fail: + be_req_terminate(be_req, DP_ERR_FATAL, ret, NULL); +} + +static void +ad_account_info_complete(struct tevent_req *req) +{ + struct be_req *be_req; + errno_t ret; + int dp_error; + const char *req_error_text; + + be_req = tevent_req_callback_data(req, struct be_req); + + ret = ad_handle_acct_info_recv(req, &dp_error, &req_error_text); + talloc_zfree(req); + if (dp_error == DP_ERR_OK) { + if (ret == EOK) { + req_error_text = NULL; + } else { + DEBUG(1, ("Bug: dp_error is OK on failed request")); + dp_error = DP_ERR_FATAL; + req_error_text = req_error_text; + } + } else if (dp_error == DP_ERR_OFFLINE) { + req_error_text = "Offline"; + } else if (dp_error == DP_ERR_FATAL && ret == ENOMEM) { + req_error_text = "Out of memory"; + } else { + req_error_text = req_error_text; + } + + return be_req_terminate(be_req, dp_error, ret, req_error_text); } void -- 1.8.2.1