summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/responder/common/responder.h3
-rw-r--r--src/responder/nss/nsssrv.h1
-rw-r--r--src/responder/nss/nsssrv_services.c659
3 files changed, 662 insertions, 1 deletions
diff --git a/src/responder/common/responder.h b/src/responder/common/responder.h
index 235b1d97..b8d7f8ab 100644
--- a/src/responder/common/responder.h
+++ b/src/responder/common/responder.h
@@ -118,6 +118,9 @@ struct cli_ctx {
int grent_dom_idx;
int grent_cur;
+ int svc_dom_idx;
+ int svcent_cur;
+
char *netgr_name;
int netgrent_cur;
};
diff --git a/src/responder/nss/nsssrv.h b/src/responder/nss/nsssrv.h
index 01a2810c..8fc0809a 100644
--- a/src/responder/nss/nsssrv.h
+++ b/src/responder/nss/nsssrv.h
@@ -52,6 +52,7 @@ struct nss_ctx {
struct getent_ctx *pctx;
struct getent_ctx *gctx;
+ struct getent_ctx *svcctx;
hash_table_t *netgroups;
bool filter_users_in_groups;
diff --git a/src/responder/nss/nsssrv_services.c b/src/responder/nss/nsssrv_services.c
index cd0ec583..9013c682 100644
--- a/src/responder/nss/nsssrv_services.c
+++ b/src/responder/nss/nsssrv_services.c
@@ -1154,18 +1154,675 @@ done:
return nss_cmd_done(cmdctx, ret);
}
+struct setservent_ctx {
+ struct cli_ctx *cctx;
+ struct nss_ctx *nctx;
+ struct nss_dom_ctx *dctx;
+ struct getent_ctx *getent_ctx;
+};
+
+static errno_t
+setservent_step(struct setent_step_ctx *step_ctx);
+static void
+setservent_step_done(struct tevent_req *req);
+
+static struct tevent_req *
+lookup_servent_send(TALLOC_CTX *mem_ctx,
+ struct resp_ctx *rctx,
+ struct sss_domain_info *dom);
+
+static struct tevent_req *
+setservent_send(TALLOC_CTX *mem_ctx, struct cli_ctx *cctx)
+{
+ errno_t ret;
+ unsigned int num_domains;
+ struct tevent_req *req;
+ struct setservent_ctx *state;
+ struct sss_domain_info *dom;
+ struct setent_step_ctx *step_ctx;
+ struct nss_ctx *nctx =
+ talloc_get_type(cctx->rctx->pvt_ctx, struct nss_ctx);
+
+ DEBUG(SSSDBG_TRACE_FUNC, ("Received setservent request\n"));
+
+ /* Reset the read pointers */
+ cctx->svc_dom_idx = 0;
+ cctx->svcent_cur = 0;
+
+ req = tevent_req_create(mem_ctx, &state, struct setservent_ctx);
+ if (!req) return NULL;
+
+ state->nctx = nctx;
+ state->cctx = cctx;
+ state->dctx = talloc_zero(state, struct nss_dom_ctx);
+ if (!state->dctx) {
+ ret = ENOMEM;
+ goto immediate;
+ }
+ state->dctx->domain = cctx->rctx->domains;
+
+ /* Is the result context already available */
+ if (state->nctx->svcctx) {
+ if (state->nctx->svcctx->ready) {
+ /* All of the necessary data is in place
+ * We can return now, getservent requests will work at this point
+ */
+ ret = EOK;
+ goto immediate;
+ }
+ else {
+ /* Object is still being constructed
+ * Register for notification when it's
+ * ready.
+ */
+ ret = setent_add_ref(state, state->nctx->svcctx, req);
+ if (ret != EOK) goto immediate;
+ }
+ return req;
+ }
+
+ /* Create a new result context
+ * We are creating it on the nss_ctx so that it doesn't
+ * go away if the original request does. We will delete
+ * it when the refcount goes to zero;
+ */
+ state->nctx->svcctx = talloc_zero(nctx, struct getent_ctx);
+ if (!state->nctx->svcctx) {
+ ret = ENOMEM;
+ goto immediate;
+ }
+ state->getent_ctx = nctx->svcctx;
+
+ /* Assume that all domains will have results (to avoid having
+ * to reallocate later
+ */
+ num_domains = 0;
+ dom = state->cctx->rctx->domains;
+ while (dom) {
+ num_domains++;
+ dom = dom->next;
+ }
+
+ state->nctx->svcctx->doms = talloc_zero_array(state->nctx->svcctx,
+ struct dom_ctx,
+ num_domains);
+ if (!state->nctx->svcctx->doms) {
+ ret = ENOMEM;
+ goto immediate;
+ }
+
+ /* Add a callback reference for ourselves */
+ setent_add_ref(state, state->nctx->svcctx, req);
+
+ /* ok, start the searches */
+ step_ctx = talloc_zero(state->getent_ctx, struct setent_step_ctx);
+ if (!step_ctx) {
+ ret = ENOMEM;
+ goto immediate;
+ }
+
+ /* Steal the dom_ctx onto the step_ctx so it doesn't go out of scope if
+ * this request is canceled while other requests are in-progress.
+ */
+ step_ctx->dctx = talloc_steal(step_ctx, state->dctx);
+ step_ctx->nctx = state->nctx;
+ step_ctx->getent_ctx = state->getent_ctx;
+ step_ctx->rctx = cctx->rctx;
+ step_ctx->cctx = cctx;
+ step_ctx->returned_to_mainloop = false;
+
+ while (step_ctx->dctx->domain) {
+ /* There are more domains to check */
+ ret = setservent_step(step_ctx);
+ if (ret == EOK) {
+ /* Re-enter the mainloop */
+ return req;
+ }
+
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Error [%s] requesting info from domain [%s]. Skipping.\n",
+ strerror(ret), step_ctx->dctx->domain->name));
+
+ step_ctx->dctx->domain = step_ctx->dctx->domain->next;
+ }
+
+ /* All domains failed */
+ ret = EIO;
+
+immediate:
+ if (ret == EOK) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_error(req, ret);
+ }
+ tevent_req_post(req, cctx->rctx->ev);
+ return req;
+}
+
+static errno_t
+setservent_step(struct setent_step_ctx *step_ctx)
+{
+ struct tevent_req *req;
+
+ req = lookup_servent_send(step_ctx,
+ step_ctx->rctx,
+ step_ctx->dctx->domain);
+ if (!req) {
+ return ENOMEM;
+ }
+ tevent_req_set_callback(req, setservent_step_done, step_ctx);
+
+ return EOK;
+}
+
+struct lookup_servent_ctx {
+ struct resp_ctx *rctx;
+ struct sss_domain_info *dom;
+ struct ldb_result *res;
+};
+
+static void
+lookup_servent_done(struct tevent_req *subreq);
+
+static void
+setservent_finalize(struct setent_step_ctx *step_ctx);
+
+static struct tevent_req *
+lookup_servent_send(TALLOC_CTX *mem_ctx,
+ struct resp_ctx *rctx,
+ struct sss_domain_info *dom)
+{
+ errno_t ret;
+ struct tevent_req *req;
+ struct tevent_req *subreq;
+ struct lookup_servent_ctx *state;
+ struct sysdb_ctx *sysdb;
+
+ req = tevent_req_create(mem_ctx, &state, struct lookup_servent_ctx);
+ if (!req) return NULL;
+
+ state->rctx = rctx;
+ state->dom = dom;
+
+ if (!dom->enumerate) {
+ ret = ENOENT;
+ goto immediate;
+ }
+
+ if (!(NEED_CHECK_PROVIDER(dom->name))) {
+ /* No provider check required. Just ask the
+ * sysdb.
+ */
+ ret = sysdb_get_ctx_from_list(rctx->db_list, dom, &sysdb);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_FATAL_FAILURE,
+ ("Sysdb CTX not found for [%s]!\n", dom->name));
+ goto immediate;
+ }
+
+ ret = sysdb_enumservent(state, sysdb, &state->res);
+ /* Whatever the result, we're done, so report it */
+ goto immediate;
+ }
+
+ /* We need to ask the provider for an enumeration */
+ /* Update the cache */
+ subreq = sss_dp_get_account_send(req, rctx, state->dom,
+ true, SSS_DP_SERVICES,
+ NULL, 0, NULL);
+ if (!subreq) {
+ ret = ENOMEM;
+ goto immediate;
+ }
+ tevent_req_set_callback(subreq, lookup_servent_done, req);
+
+ return req;
+
+immediate:
+ if (ret == EOK) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_error(req, ENOENT);
+ }
+ tevent_req_post(req, rctx->ev);
+ return req;
+}
+
+static void
+lookup_servent_done(struct tevent_req *subreq)
+{
+ errno_t ret;
+ dbus_uint16_t dp_err;
+ dbus_uint32_t dp_ret;
+ char *err_msg;
+ struct sysdb_ctx *sysdb;
+ struct tevent_req *req =
+ tevent_req_callback_data(subreq, struct tevent_req);
+ struct lookup_servent_ctx *state =
+ tevent_req_data(req, struct lookup_servent_ctx);
+
+ ret = sss_dp_get_account_recv(state, subreq,
+ &dp_err, &dp_ret, &err_msg);
+ talloc_zfree(subreq);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_OP_FAILURE,
+ ("Unable to get information from Data Provider\n"
+ "dp_error: [%u], errno: [%u], error_msg: [%s]\n"
+ "Will try to return what we have in cache\n",
+ (unsigned int)dp_err, (unsigned int)dp_ret,
+ err_msg ? err_msg : "none"));
+ }
+
+ /* Check the cache now */
+ ret = sysdb_get_ctx_from_list(state->rctx->db_list, state->dom, &sysdb);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_FATAL_FAILURE,
+ ("Sysdb CTX not found for [%s]!\n", state->dom->name));
+ goto done;
+ }
+
+ ret = sysdb_enumservent(state, sysdb, &state->res);
+ /* Whatever the result, we're done, so report it */
+
+done:
+ if (ret == EOK) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_error(req, ret);
+ }
+}
+
+static errno_t
+lookup_servent_recv(TALLOC_CTX *mem_ctx,
+ struct tevent_req *req,
+ struct ldb_result **res)
+{
+ struct lookup_servent_ctx *state =
+ tevent_req_data(req, struct lookup_servent_ctx);
+
+ TEVENT_REQ_RETURN_ON_ERROR(req);
+
+ *res = talloc_steal(mem_ctx, state->res);
+ return EOK;
+}
+
+static void
+setservent_step_done(struct tevent_req *req)
+{
+ errno_t ret;
+ struct ldb_result *res;
+ struct setent_step_ctx *step_ctx =
+ tevent_req_callback_data(req, struct setent_step_ctx);
+ struct nss_dom_ctx *dctx = step_ctx->dctx;
+ struct getent_ctx *svcctx = step_ctx->getent_ctx;
+
+
+ ret = lookup_servent_recv(step_ctx, req, &res);
+ talloc_zfree(req);
+ if (ret == ENOENT) {
+ DEBUG(SSSDBG_TRACE_FUNC,
+ ("Domain [%d] returned no results\n", dctx->domain->name));
+ } else if (ret != EOK) {
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Error [%s] while retrieving info from domain [%s]. "
+ "Skipping.\n", strerror(ret), dctx->domain->name));
+ /* Continue on */
+ } else {
+ /* Got some results
+ * Add the retrieved results to the list
+ */
+ svcctx->doms[svcctx->num].domain = dctx->domain;
+ svcctx->doms[svcctx->num].res = talloc_steal(svcctx->doms, res);
+ svcctx->num++;
+ }
-int nss_cmd_setservent(struct cli_ctx *cctx)
+ step_ctx->dctx->domain = step_ctx->dctx->domain->next;
+
+ while (step_ctx->dctx->domain) {
+ /* There are more domains to check */
+ ret = setservent_step(step_ctx);
+ if (ret == EOK) {
+ /* Re-enter the mainloop */
+ return;
+ }
+
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Error [%s] requesting info from domain [%s]. Skipping.\n",
+ strerror(ret), step_ctx->dctx->domain->name));
+
+ step_ctx->dctx->domain = step_ctx->dctx->domain->next;
+ }
+
+ /* All domains have been checked */
+ setservent_finalize(step_ctx);
+}
+
+static void
+setservent_result_timeout(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval current_time,
+ void *pvt);
+
+static void
+setservent_finalize(struct setent_step_ctx *step_ctx)
+{
+ struct nss_ctx *nctx = step_ctx->nctx;
+ struct resp_ctx *rctx = step_ctx->rctx;
+ struct timeval tv;
+ struct tevent_timer *te;
+ struct setent_req_list *reql;
+
+ /* We've finished all our lookups
+ * The result object is now safe to read.
+ */
+ nctx->svcctx->ready = true;
+
+ /* Set up a lifetime timer for this result object
+ * We don't want this result object to outlive the
+ * enum cache refresh timeout
+ */
+ tv = tevent_timeval_current_ofs(nctx->enum_cache_timeout, 0);
+ te = tevent_add_timer(rctx->ev, nctx->svcctx, tv,
+ setservent_result_timeout, nctx);
+ if (!te) {
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Could not set up life timer for setservent result object. "
+ "Entries may become stale.\n"));
+ }
+
+ /* Notify the waiting clients */
+ while ((reql = nctx->svcctx->reqs)) {
+ /* Each tevent_req_done() call will free
+ * the request, removing it from the list.
+ */
+ tevent_req_done(reql->req);
+
+ if (reql == nctx->svcctx->reqs) {
+ /* The consumer failed to free the
+ * request. Log a bug and continue.
+ */
+ DEBUG(SSSDBG_FATAL_FAILURE,
+ ("BUG: a callback did not free its request. "
+ "May leak memory\n"));
+ /* Skip to the next since a memory leak is non-fatal */
+ nctx->svcctx->reqs = nctx->svcctx->reqs->next;
+ }
+ }
+}
+
+static void
+setservent_result_timeout(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval current_time,
+ void *pvt)
{
+ struct nss_ctx *nctx = talloc_get_type(pvt, struct nss_ctx);
+
+ DEBUG(SSSDBG_TRACE_FUNC,
+ ("setservent result object has expired. Cleaning up.\n"));
+
+ /* Free the service enumeration context.
+ * If additional getservent requests come in, they will invoke
+ * an implicit setservent and refresh the result object.
+ */
+ talloc_zfree(nctx->svcctx);
+}
+
+static errno_t
+setservent_recv(struct tevent_req *req)
+{
+ TEVENT_REQ_RETURN_ON_ERROR(req);
return EOK;
}
+static void
+nss_cmd_setservent_done(struct tevent_req *req);
+
+int
+nss_cmd_setservent(struct cli_ctx *cctx)
+{
+ struct nss_cmd_ctx *cmdctx;
+ struct tevent_req *req;
+ errno_t ret = EOK;
+
+ cmdctx = talloc_zero(cctx, struct nss_cmd_ctx);
+ if (!cmdctx) {
+ return ENOMEM;
+ }
+ cmdctx->cctx = cctx;
+
+ req = setservent_send(cmdctx, cctx);
+ if (!req) {
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Fatal error calling nss_cmd_setservent_send\n"));
+ ret = EIO;
+ goto done;
+ }
+ tevent_req_set_callback(req, nss_cmd_setservent_done, cmdctx);
+
+done:
+ return nss_cmd_done(cmdctx, ret);
+}
+
+static void
+nss_cmd_setservent_done(struct tevent_req *req)
+{
+ errno_t ret;
+ struct nss_cmd_ctx *cmdctx =
+ tevent_req_callback_data(req, struct nss_cmd_ctx);
+
+ ret = setservent_recv(req);
+ talloc_zfree(req);
+ if (ret == EOK || ret == ENOENT) {
+ /* Either we succeeded or no domains
+ * were eligible.
+ * Return an acknowledgment
+ */
+ ret = sss_packet_new(cmdctx->cctx->creq, 0,
+ sss_packet_get_cmd(cmdctx->cctx->creq->in),
+ &cmdctx->cctx->creq->out);
+ if (ret == EOK) {
+ sss_cmd_done(cmdctx->cctx, cmdctx);
+ return;
+ }
+ }
+
+ /* Something bad happened.
+ * Return an error
+ */
+ nss_cmd_done(cmdctx, ret);
+}
+
+static void
+nss_cmd_implicit_setservent_done(struct tevent_req *req);
+
+static errno_t
+nss_cmd_getservent_immediate(struct nss_cmd_ctx *cmdctx);
+
+static errno_t
+retservent(struct cli_ctx *cctx, int num);
+
int nss_cmd_getservent(struct cli_ctx *cctx)
{
+ struct nss_ctx *nctx;
+ struct nss_cmd_ctx *cmdctx;
+ struct tevent_req *req;
+
+ DEBUG(SSSDBG_TRACE_FUNC,
+ ("Requesting info for all services\n"));
+
+ cmdctx = talloc_zero(cctx, struct nss_cmd_ctx);
+ if (!cmdctx) {
+ return ENOMEM;
+ }
+ cmdctx->cctx = cctx;
+
+ /* Save the current index and cursor locations
+ * If we end up calling setservent implicitly, because the response object
+ * expired and has to be recreated, we want to resume from the same
+ * location.
+ */
+ cmdctx->saved_dom_idx = cctx->svc_dom_idx;
+ cmdctx->saved_cur = cctx->svcent_cur;
+
+ nctx = talloc_get_type(cctx->rctx->pvt_ctx, struct nss_ctx);
+ if(!nctx->svcctx || !nctx->svcctx->ready) {
+ /* Make sure we invoke setservent if it hasn't been run or is still
+ * processing from another client
+ */
+ req = setservent_send(cmdctx, cctx);
+ if (!req) {
+ return EIO;
+ }
+ tevent_req_set_callback(req,
+ nss_cmd_implicit_setservent_done,
+ cmdctx);
+ return EOK;
+ }
+
+ return nss_cmd_getservent_immediate(cmdctx);
+}
+
+static void
+nss_cmd_implicit_setservent_done(struct tevent_req *req)
+{
+ errno_t ret;
+ struct nss_cmd_ctx *cmdctx =
+ tevent_req_callback_data(req, struct nss_cmd_ctx);
+
+ ret = setservent_recv(req);
+ talloc_zfree(req);
+
+ /* ENOENT is acceptable, as it just means that there were no entries
+ * to be returned. This will be handled gracefully in retservent
+ * later.
+ */
+ if (ret != EOK && ret != ENOENT) {
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Implicit setservent failed with unexpected error [%d][%s]\n",
+ ret, strerror(ret)));
+ NSS_CMD_FATAL_ERROR(cmdctx);
+ }
+
+ /* Restore the saved index and cursor locations */
+ cmdctx->cctx->svc_dom_idx = cmdctx->saved_dom_idx;
+ cmdctx->cctx->svcent_cur = cmdctx->saved_cur;
+
+ ret = nss_cmd_getservent_immediate(cmdctx);
+ if (ret != EOK) {
+ DEBUG(SSSDBG_CRIT_FAILURE,
+ ("Immediate retrieval failed with unexpected error "
+ "[%d][%s]\n", ret, strerror(ret)));
+ NSS_CMD_FATAL_ERROR(cmdctx);
+ }
+}
+
+static errno_t
+nss_cmd_getservent_immediate(struct nss_cmd_ctx *cmdctx)
+{
+ struct cli_ctx *cctx = cmdctx->cctx;
+ uint8_t *body;
+ size_t blen;
+ uint32_t num;
+ int ret;
+
+ /* get max num of entries to return in one call */
+ sss_packet_get_body(cctx->creq->in, &body, &blen);
+ if (blen != sizeof(uint32_t)) {
+ return EINVAL;
+ }
+ num = *((uint32_t *)body);
+
+ /* create response packet */
+ ret = sss_packet_new(cctx->creq, 0,
+ sss_packet_get_cmd(cctx->creq->in),
+ &cctx->creq->out);
+ if (ret != EOK) {
+ return ret;
+ }
+
+ ret = retservent(cctx, num);
+
+ sss_packet_set_error(cctx->creq->out, ret);
+ sss_cmd_done(cctx, cmdctx);
+
return EOK;
}
+static errno_t
+retservent(struct cli_ctx *cctx, int num)
+{
+ struct nss_ctx *nctx;
+ struct getent_ctx *svcctx;
+ struct ldb_message **msgs = NULL;
+ struct dom_ctx *pdom = NULL;
+ unsigned int n = 0;
+ int ret = ENOENT;
+
+ nctx = talloc_get_type(cctx->rctx->pvt_ctx, struct nss_ctx);
+ if (!nctx->svcctx) goto none;
+
+ svcctx = nctx->svcctx;
+
+ while (ret == ENOENT) {
+ if (cctx->svc_dom_idx >= svcctx->num) break;
+
+ pdom = &svcctx->doms[cctx->svc_dom_idx];
+
+ n = pdom->res->count - cctx->svcent_cur;
+ if (n <= 0 && (cctx->svc_dom_idx+1 < svcctx->num)) {
+ cctx->svc_dom_idx++;
+ pdom = &svcctx->doms[cctx->svc_dom_idx];
+ n = pdom->res->count;
+ cctx->svcent_cur = 0;
+ }
+
+ if (!n) break;
+
+ if (n > num) n = num;
+
+ msgs = &(pdom->res->msgs[cctx->svcent_cur]);
+
+ ret = fill_service(cctx->creq->out,
+ pdom->domain,
+ nctx, msgs,
+ &n);
+
+ cctx->svcent_cur += n;
+ }
+
+none:
+ if (ret == ENOENT) {
+ ret = fill_empty(cctx->creq->out);
+ }
+ return ret;
+}
+
int nss_cmd_endservent(struct cli_ctx *cctx)
{
+ struct nss_ctx *nctx;
+ int ret;
+
+ DEBUG(SSSDBG_TRACE_FUNC,
+ ("Terminating request info for all accounts\n"));
+
+ nctx = talloc_get_type(cctx->rctx->pvt_ctx, struct nss_ctx);
+
+ /* create response packet */
+ ret = sss_packet_new(cctx->creq, 0,
+ sss_packet_get_cmd(cctx->creq->in),
+ &cctx->creq->out);
+
+ if (ret != EOK) {
+ return ret;
+ }
+ if (nctx->svcctx == NULL) goto done;
+
+ /* Reset the indices so that subsequent requests start at zero */
+ cctx->svc_dom_idx = 0;
+ cctx->svcent_cur = 0;
+
+done:
+ sss_cmd_done(cctx, NULL);
return EOK;
}