summaryrefslogtreecommitdiff
path: root/server
diff options
context:
space:
mode:
authorSimo Sorce <ssorce@redhat.com>2009-07-02 18:06:56 -0400
committerSimo Sorce <ssorce@redhat.com>2009-07-03 11:07:36 -0400
commit19727007c9948ee92a9505efae6692ea38c96a3e (patch)
tree4512d5431c9fce46e7a1f522352f9c0dd38a5cd8 /server
parent94ec51d8b53f636d41a879ed1d0d39127168cb21 (diff)
downloadsssd-19727007c9948ee92a9505efae6692ea38c96a3e.tar.gz
sssd-19727007c9948ee92a9505efae6692ea38c96a3e.tar.bz2
sssd-19727007c9948ee92a9505efae6692ea38c96a3e.zip
Convert proxy internals to tevent_req style
Diffstat (limited to 'server')
-rw-r--r--server/providers/proxy.c2303
1 files changed, 1438 insertions, 865 deletions
diff --git a/server/providers/proxy.c b/server/providers/proxy.c
index 9bbfdbd6..048f31f1 100644
--- a/server/providers/proxy.c
+++ b/server/providers/proxy.c
@@ -3,7 +3,7 @@
Proxy Module
- Copyright (C) Simo Sorce <ssorce@redhat.com> 2008
+ Copyright (C) Simo Sorce <ssorce@redhat.com> 2008-2009
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
@@ -71,12 +71,6 @@ struct authtok_conv {
uint8_t *authtok;
};
-static void cache_password(struct be_req *req,
- const char *username,
- struct authtok_conv *ac);
-static void proxy_reply(struct be_req *req,
- int error, const char *errstr);
-
static void offline_timeout(struct tevent_context *ev, struct tevent_timer *tt,
struct timeval tv, void *pvt)
{
@@ -163,6 +157,16 @@ failed:
return PAM_CONV_ERR;
}
+static void proxy_pam_handler_cache_done(struct tevent_req *treq);
+static struct tevent_req *cache_password_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ const char *username,
+ struct authtok_conv *ac);
+static void proxy_reply(struct be_req *req,
+ int error, const char *errstr);
+
static void proxy_pam_handler(struct be_req *req) {
int ret;
int pam_status;
@@ -253,38 +257,33 @@ static void proxy_pam_handler(struct be_req *req) {
pd->pam_status = pam_status;
if (cache_auth_data) {
- cache_password(req, pd->user, auth_data);
- return;
+ struct tevent_req *treq;
+
+ treq = cache_password_send(req, req->be_ctx->ev,
+ req->be_ctx->sysdb,
+ req->be_ctx->domain,
+ pd->user, auth_data);
+ if (!treq) {
+ /* password caching failures are not fatal errors */
+ return proxy_reply(req, EOK, NULL);
+ }
+ tevent_req_set_callback(treq, proxy_pam_handler_cache_done, req);
}
proxy_reply(req, EOK, NULL);
}
-struct proxy_data {
- struct tevent_context *ev;
- /* FIXME: should not store it here */
- struct tevent_req *treq;
-
- struct sysdb_handle *handle;
- struct proxy_ctx *ctx;
- struct be_req *req;
-
- char *buffer;
- size_t buflen;
-
- struct passwd *pwd;
- struct group *grp;
-
- gid_t *groups;
- long int num;
- long int cur;
+static void proxy_pam_handler_cache_done(struct tevent_req *treq)
+{
+ struct be_req *req = tevent_req_callback_data(treq, struct be_req);
- struct ldb_dn *dn;
+ /* password caching failures are not fatal errors */
- sysdb_callback_t next_fn;
+ /* so we just ignore any return */
+ talloc_zfree(treq);
- const char *err;
-};
+ return proxy_reply(req, EOK, NULL);
+}
static void proxy_reply(struct be_req *req, int error, const char *errstr)
{
@@ -292,1041 +291,1358 @@ static void proxy_reply(struct be_req *req, int error, const char *errstr)
return req->fn(req, error, errstr);
}
-static void proxy_req_done(struct tevent_req *req)
-{
- struct proxy_data *data = tevent_req_callback_data(req, struct proxy_data);
- int ret;
+/* =Common-proxy-tevent_req-utils=========================================*/
- ret = sysdb_transaction_commit_recv(req);
- if (ret) {
- DEBUG(2, ("Failed to cache password (%d)[%s]!?\n",
- ret, strerror(ret)));
- }
+#define DEFAULT_BUFSIZE 4096
+#define MAX_BUF_SIZE 1024*1024 /* max 1MiB */
- /* password caching failures are not fatal errors */
- proxy_reply(data->req, EOK, data->err);
-}
+struct proxy_state {
+ struct tevent_context *ev;
+ struct proxy_ctx *ctx;
+ struct sysdb_ctx *sysdb;
+ struct sss_domain_info *domain;
+ const char *name;
+
+ struct sysdb_handle *handle;
+ struct passwd *pwd;
+ struct group *grp;
+ uid_t uid;
+ gid_t gid;
+};
-static void cache_pw_return(struct tevent_req *subreq)
+static void proxy_default_done(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
- struct tevent_req *req;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
int ret;
- ret = sysdb_set_cached_password_recv(subreq);
+ ret = sysdb_transaction_commit_recv(subreq);
talloc_zfree(subreq);
- if (ret != EOK) {
- goto fail;
- }
-
- req = sysdb_transaction_commit_send(data, data->ev, data->handle);
- if (!req) {
- ret = ENOMEM;
- goto fail;
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
}
- tevent_req_set_callback(req, proxy_req_done, data);
-
- return;
-fail:
- DEBUG(2, ("Failed to cache password (%d)[%s]!?\n", ret, strerror(ret)));
-
- /* free transaction */
- talloc_zfree(data->handle);
-
- /* password caching failures are not fatal errors */
- proxy_reply(data->req, EOK, NULL);
+ tevent_req_done(req);
}
-static void cache_pw_op(struct tevent_req *req)
+static int proxy_default_recv(struct tevent_req *req)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
- int ret;
+ enum tevent_req_state tstate;
+ uint64_t err = 0;
- ret = sysdb_transaction_recv(req, data, &data->handle);
- if (ret) {
- /* password caching failures are not fatal errors */
- return proxy_reply(data->req, EOK, NULL);
+ if (tevent_req_is_error(req, &tstate, &err)) {
+ if (err != 0) return err;
+ return EIO;
}
- subreq = sysdb_set_cached_password_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->pwd->pw_name,
- data->pwd->pw_passwd);
- if (!subreq) {
- /* password caching failures are not fatal errors */
- proxy_reply(data->req, EOK, NULL);
- }
- tevent_req_set_callback(subreq, cache_pw_return, data);
+ return EOK;
}
-static void cache_password(struct be_req *req,
- const char *username,
- struct authtok_conv *ac)
-{
- struct proxy_data *data;
- struct proxy_ctx *ctx;
- struct tevent_req *treq;
-
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->pwd = talloc(data, struct passwd);
- if (!data->pwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->pwd->pw_name = talloc_strdup(data, username);
- if (!data->pwd->pw_name)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->pwd->pw_passwd = talloc_size(data, ac->authtok_size + 1);
- if (!data->pwd->pw_passwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
- memcpy(data->pwd->pw_passwd, ac->authtok, ac->authtok_size);
- data->pwd->pw_passwd[ac->authtok_size] = '\0';
-
- talloc_set_destructor((TALLOC_CTX *)data->pwd->pw_passwd,
- password_destructor);
- data->ev = req->be_ctx->ev;
+/* =Password-Caching======================================================*/
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- /* password caching failures are not fatal errors */
- return proxy_reply(req, EOK, NULL);
- }
+struct cache_pw_state {
+ struct tevent_context *ev;
+ struct sss_domain_info *domain;
+ const char *name;
+ char *passwd;
- tevent_req_set_callback(treq, cache_pw_op, data);
-}
+ struct sysdb_handle *handle;
+};
-static void proxy_return(void *pvt, int error, struct ldb_result *ignore)
+static void cache_password_process(struct tevent_req *subreq);
+static void cache_password_done(struct tevent_req *subreq);
+
+static struct tevent_req *cache_password_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ const char *username,
+ struct authtok_conv *ac)
{
- struct proxy_data *data = talloc_get_type(pvt, struct proxy_data);
- struct tevent_req *req;
+ struct tevent_req *req, *subreq;
+ struct cache_pw_state *state;
int ret;
- if (error != EOK) {
- data->err = "Operation failed";
- ret = error;
+ req = tevent_req_create(mem_ctx, &state, struct cache_pw_state);
+ if (!req) {
+ ret = ENOMEM;
goto fail;
}
- req = sysdb_transaction_commit_send(data, data->ev, data->handle);
- if (!req) {
- data->err = "Operation failed";
+ state->ev = ev;
+ state->handle = NULL;
+ state->name = username;
+
+ state->passwd = talloc_size(state, ac->authtok_size + 1);
+ if (!state->passwd) {
ret = ENOMEM;
goto fail;
}
+ memcpy(state->passwd, ac->authtok, ac->authtok_size);
+ state->passwd[ac->authtok_size] = '\0';
+ talloc_set_destructor((TALLOC_CTX *)state->passwd,
+ password_destructor);
- tevent_req_set_callback(req, proxy_req_done, data);
+ req = sysdb_transaction_send(state, state->ev, sysdb);
+ if (!req) {
+ ret = ENOMEM;
+ goto fail;
+ }
+ tevent_req_set_callback(subreq, cache_password_process, req);
- return;
+ return req;
fail:
- /* free transaction */
- talloc_zfree(data->handle);
-
- /* password caching failures are not fatal errors */
- proxy_reply(data->req, EOK, NULL);
+ tevent_req_error(req, ret);
+ tevent_req_post(req, ev);
+ return req;
}
-static void del_db_entry_done(struct tevent_req *subreq);
-static void del_db_entry(struct tevent_req *req)
+static void cache_password_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct cache_pw_state *state = tevent_req_data(req,
+ struct cache_pw_state);
int ret;
- ret = sysdb_transaction_recv(req, data, &data->handle);
+ ret = sysdb_transaction_recv(req, state, &state->handle);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
- subreq = sysdb_delete_entry_send(data, data->ev, data->handle, data->dn);
+ subreq = sysdb_set_cached_password_send(state, state->ev, state->handle,
+ state->domain,
+ state->name,
+ state->passwd);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ tevent_req_error(req, ENOMEM);
+ return;
}
- tevent_req_set_callback(subreq, del_db_entry_done, data);
+ tevent_req_set_callback(subreq, cache_password_done, req);
}
-static void del_db_entry_done(struct tevent_req *subreq)
+static void cache_password_done(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct cache_pw_state *state = tevent_req_data(req,
+ struct cache_pw_state);
int ret;
- ret = sysdb_delete_entry_recv(subreq);
+ ret = sysdb_set_cached_password_recv(subreq);
talloc_zfree(subreq);
if (ret) {
- return proxy_return(data, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
- data->next_fn(data, EOK, NULL);
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
}
-static void del_pw_uid_done(struct tevent_req *subreq);
-static void del_pw_uid(struct tevent_req *req)
+
+/* =Getpwnam-wrapper======================================================*/
+
+static void get_pw_name_process(struct tevent_req *subreq);
+static void get_pw_name_remove_done(struct tevent_req *subreq);
+static void get_pw_name_add_done(struct tevent_req *subreq);
+
+static struct tevent_req *get_pw_name_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ const char *name)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
- int ret;
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
- ret = sysdb_transaction_recv(req, data, &data->handle);
- if (ret) {
- return proxy_reply(data->req, ret, NULL);
- }
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
+
+ memset(state, 0, sizeof(struct proxy_state));
- subreq = sysdb_delete_user_by_uid_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->pwd->pw_uid);
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
+ state->name = name;
+
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ talloc_zfree(req);
+ return NULL;
}
- tevent_req_set_callback(subreq, del_pw_uid_done, data);
+ tevent_req_set_callback(subreq, get_pw_name_process, req);
+
+ return req;
}
-static void del_pw_uid_done(struct tevent_req *subreq)
+static void get_pw_name_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
+ enum nss_status status;
+ char *buffer;
+ size_t buflen;
+ bool delete_user = false;
int ret;
- ret = sysdb_delete_user_by_uid_recv(subreq);
- talloc_zfree(subreq);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
if (ret) {
- return proxy_return(data, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
+ talloc_zfree(subreq);
- data->next_fn(data, EOK, NULL);
-}
+ state->pwd = talloc(state, struct passwd);
+ if (!state->pwd) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ /* FIXME: should we move this call outside the transaction to keep the
+ * transaction as short as possible ? */
+ status = ctx->ops.getpwnam_r(state->name, state->pwd,
+ buffer, buflen, &ret);
+
+ switch (status) {
+ case NSS_STATUS_NOTFOUND:
+
+ delete_user = true;
+ break;
+
+ case NSS_STATUS_SUCCESS:
+
+ /* uid=0 or gid=0 are invalid values */
+ if (state->pwd->pw_uid == 0 || state->pwd->pw_gid == 0) {
+ delete_user = true;
+ break;
+ }
+
+ subreq = sysdb_store_user_send(state, state->ev, state->handle,
+ state->domain,
+ state->pwd->pw_name,
+ state->pwd->pw_passwd,
+ state->pwd->pw_uid,
+ state->pwd->pw_gid,
+ state->pwd->pw_gecos,
+ state->pwd->pw_dir,
+ state->pwd->pw_shell);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_pw_name_add_done, req);
+ return;
+
+ case NSS_STATUS_UNAVAIL:
+ /* "remote" backend unavailable. Enter offline mode */
+ tevent_req_error(req, ENXIO);
+ return;
+
+ default:
+ DEBUG(2, ("proxy -> getpwnam_r failed for '%s' <%d>\n",
+ state->name, status));
+ tevent_req_error(req, EIO);
+ return;
+ }
+
+ if (delete_user) {
+ struct ldb_dn *dn;
-static void set_pw_name_done(struct tevent_req *subreq);
+ dn = sysdb_user_dn(state->sysdb, state,
+ state->domain->name, state->name);
+ if (!dn) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
-static void set_pw_name(struct tevent_req *req)
+ subreq = sysdb_delete_entry_send(state, state->ev, state->handle, dn);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_pw_name_remove_done, req);
+ }
+}
+
+static void get_pw_name_add_done(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
int ret;
- ret = sysdb_transaction_recv(req, data, &data->handle);
+ ret = sysdb_store_user_recv(subreq);
+ talloc_zfree(subreq);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
- subreq = sysdb_store_user_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->pwd->pw_name, data->pwd->pw_passwd,
- data->pwd->pw_uid, data->pwd->pw_gid,
- data->pwd->pw_gecos, data->pwd->pw_dir,
- data->pwd->pw_shell);
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
if (!subreq) {
- proxy_return(data, ret, NULL);
+ tevent_req_error(req, ENOMEM);
return;
}
- tevent_req_set_callback(subreq, set_pw_name_done, data);
+ tevent_req_set_callback(subreq, proxy_default_done, req);
}
-static void set_pw_name_done(struct tevent_req *subreq)
+static void get_pw_name_remove_done(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
int ret;
- ret = sysdb_store_user_recv(subreq);
+ ret = sysdb_delete_entry_recv(subreq);
+ talloc_zfree(subreq);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
- data->next_fn(data, EOK, NULL);
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
}
+/* =Getpwuid-wrapper======================================================*/
+
+static void get_pw_uid_process(struct tevent_req *subreq);
+static void get_pw_uid_remove_done(struct tevent_req *subreq);
-static void get_pw_name(struct be_req *req, char *name)
+static struct tevent_req *get_pw_uid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ uid_t uid)
{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
+
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
+
+ memset(state, 0, sizeof(struct proxy_state));
+
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
+ state->uid = uid;
+
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ talloc_zfree(req);
+ return NULL;
+ }
+ tevent_req_set_callback(subreq, get_pw_uid_process, req);
+
+ return req;
+}
+
+static void get_pw_uid_process(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
enum nss_status status;
- struct proxy_data *data;
+ char *buffer;
+ size_t buflen;
+ bool delete_user = false;
int ret;
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+ talloc_zfree(subreq);
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->pwd = talloc(data, struct passwd);
- if (!data->pwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ state->pwd = talloc(state, struct passwd);
+ if (!state->pwd) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
- status = ctx->ops.getpwnam_r(name, data->pwd,
- data->buffer, data->buflen, &ret);
+ status = ctx->ops.getpwuid_r(state->uid, state->pwd,
+ buffer, buflen, &ret);
switch (status) {
case NSS_STATUS_NOTFOUND:
- data->dn = sysdb_user_dn(req->be_ctx->sysdb, data,
- req->be_ctx->domain->name, name);
- if (!data->dn)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
- tevent_req_set_callback(treq, del_db_entry, data);
+ delete_user = true;
break;
case NSS_STATUS_SUCCESS:
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
- /* FIXME: verify user does not have uid=0 or gid=0 as these are invalid
- * values */
- if (data->pwd->pw_uid == 0 || data->pwd->pw_gid == 0) {
-
- tevent_req_set_callback(treq, del_db_entry, data);
+ /* uid=0 or gid=0 are invalid values */
+ if (state->pwd->pw_uid == 0 || state->pwd->pw_gid == 0) {
+ delete_user = true;
break;
}
- tevent_req_set_callback(treq, set_pw_name, data);
- break;
+ subreq = sysdb_store_user_send(state, state->ev, state->handle,
+ state->domain,
+ state->pwd->pw_name,
+ state->pwd->pw_passwd,
+ state->pwd->pw_uid,
+ state->pwd->pw_gid,
+ state->pwd->pw_gecos,
+ state->pwd->pw_dir,
+ state->pwd->pw_shell);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_pw_name_add_done, req);
+ return;
case NSS_STATUS_UNAVAIL:
/* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(req->be_ctx);
- return proxy_reply(req, EAGAIN, "Offline");
+ tevent_req_error(req, ENXIO);
+ return;
default:
- DEBUG(2, ("proxy -> getpwnam_r failed for '%s' <%d>\n", name, status));
- return proxy_reply(req, EOK, "Operation failed");
+ DEBUG(2, ("proxy -> getpwnam_r failed for '%s' <%d>\n",
+ state->name, status));
+ tevent_req_error(req, EIO);
+ return;
+ }
+
+ if (delete_user) {
+ subreq = sysdb_delete_user_by_uid_send(state, state->ev,
+ state->handle,
+ state->domain,
+ state->uid);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_pw_uid_remove_done, req);
}
}
-static void get_pw_uid(struct be_req *req, uid_t uid)
+static void get_pw_uid_remove_done(struct tevent_req *subreq)
{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
- enum nss_status status;
- struct proxy_data *data;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
int ret;
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->pwd = talloc(data, struct passwd);
- if (!data->pwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ ret = sysdb_delete_user_by_uid_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+}
- status = ctx->ops.getpwuid_r(uid, data->pwd,
- data->buffer, data->buflen, &ret);
+/* =Getpwent-wrapper======================================================*/
- switch (status) {
- case NSS_STATUS_NOTFOUND:
- data->pwd->pw_uid = uid;
+static void enum_users_process(struct tevent_req *subreq);
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
+static struct tevent_req *enum_users_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain)
+{
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
+ enum nss_status status;
- tevent_req_set_callback(treq, del_pw_uid, data);
- break;
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
- case NSS_STATUS_SUCCESS:
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
+ memset(state, 0, sizeof(struct proxy_state));
- /* FIXME: verify user does not have gid=0 as these are invalid values */
- if (data->pwd->pw_gid == 0) {
- data->dn = sysdb_user_dn(req->be_ctx->sysdb, data,
- req->be_ctx->domain->name,
- data->pwd->pw_name);
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
- tevent_req_set_callback(treq, del_db_entry, data);
- break;
- }
+ status = ctx->ops.setpwent();
+ if (status != NSS_STATUS_SUCCESS) {
+ tevent_req_error(req, EIO);
+ goto fail;
+ }
- tevent_req_set_callback(treq, set_pw_name, data);
- break;
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ goto fail;
+ }
+ tevent_req_set_callback(subreq, enum_users_process, req);
- case NSS_STATUS_UNAVAIL:
- /* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(req->be_ctx);
- return proxy_reply(req, EAGAIN, "Offline");
+ return req;
- default:
- DEBUG(2, ("proxy -> getpwuid_r failed for '%lu' (%d)[%s]\n",
- (unsigned long)uid, ret, strerror(ret)));
- return proxy_reply(req, ret, "Operation failed");
- }
+fail:
+ tevent_req_post(req, ev);
+ return req;
}
-#define MAX_BUF_SIZE 1024*1024 /* max 1MiB */
-
-static void get_pw_entry_store_done(struct tevent_req *subreq);
-static void get_pw_entry(struct tevent_req *req)
+static void enum_users_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
enum nss_status status;
- struct tevent_req *subreq;
- char *newb;
+ char *buffer;
+ char *newbuf;
+ size_t buflen;
int ret;
- data->treq = req;
-
- ret = sysdb_transaction_recv(req, data, &data->handle);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
+ talloc_zfree(subreq);
-retry:
- status = data->ctx->ops.getpwent_r(data->pwd,
- data->buffer, data->buflen, &ret);
+ state->pwd = talloc(state, struct passwd);
+ if (!state->pwd) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ /* getpwent is synchronous so instead of artifically wrapping it
+ * in fake async calls let's just loop here */
+
+again:
+ status = ctx->ops.getpwent_r(state->pwd, buffer, buflen, &ret);
switch (status) {
case NSS_STATUS_TRYAGAIN:
/* buffer too small ? */
- if (data->buflen < MAX_BUF_SIZE) {
- data->buflen *= 2;
+ if (buflen < MAX_BUF_SIZE) {
+ buflen *= 2;
}
- if (data->buflen > MAX_BUF_SIZE) {
- data->buflen = MAX_BUF_SIZE;
+ if (buflen > MAX_BUF_SIZE) {
+ buflen = MAX_BUF_SIZE;
}
- newb = talloc_realloc_size(data, data->buffer, data->buflen);
- if (!newb) {
- return proxy_return(data, ENOMEM, NULL);
+ newbuf = talloc_realloc_size(state, buffer, buflen);
+ if (!newbuf) {
+ ret = ENOMEM;
+ goto fail;
}
- data->buffer = newb;
- goto retry;
+ buffer = newbuf;
+ goto again;
case NSS_STATUS_NOTFOUND:
-
- data->ctx->ops.endpwent();
- data->next_fn(data, EOK, NULL);
- break;
+ /* we are done here */
+ ctx->ops.endpwent();
+ subreq = sysdb_transaction_commit_send(state, state->ev,
+ state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+ return;
case NSS_STATUS_SUCCESS:
- /* FIXME: verify user does not have uid=0 or gid=0 as these are invalid
- * values */
- if (data->pwd->pw_uid == 0 || data->pwd->pw_gid == 0) {
- goto retry; /* skip */
+ /* uid=0 or gid=0 are invalid values */
+ if (state->pwd->pw_uid == 0 || state->pwd->pw_gid == 0) {
+ goto again; /* skip */
}
- subreq = sysdb_store_user_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->pwd->pw_name,
- data->pwd->pw_passwd,
- data->pwd->pw_uid,
- data->pwd->pw_gid,
- data->pwd->pw_gecos,
- data->pwd->pw_dir,
- data->pwd->pw_shell);
+ subreq = sysdb_store_user_send(state, state->ev, state->handle,
+ state->domain,
+ state->pwd->pw_name,
+ state->pwd->pw_passwd,
+ state->pwd->pw_uid,
+ state->pwd->pw_gid,
+ state->pwd->pw_gecos,
+ state->pwd->pw_dir,
+ state->pwd->pw_shell);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ tevent_req_error(req, ENOMEM);
return;
}
- tevent_req_set_callback(subreq, get_pw_entry_store_done, data);
- break;
+ /* SYNC WAIT: (polls until req is done) */
+ if (!tevent_req_poll(subreq, state->ev)) {
+ tevent_req_error(req, EFAULT);
+ return;
+ }
+ ret = sysdb_store_user_recv(subreq);
+
+ goto again; /* next one */
case NSS_STATUS_UNAVAIL:
/* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(data->req->be_ctx);
- return proxy_return(data, EAGAIN, NULL);
+ ret = ENXIO;
+ goto fail;
default:
DEBUG(2, ("proxy -> getpwent_r failed (%d)[%s]\n",
ret, strerror(ret)));
- proxy_return(data, ret, NULL);
- }
-}
-
-static void get_pw_entry_store_done(struct tevent_req *subreq)
-{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
- int ret;
-
- ret = sysdb_store_user_recv(subreq);
- talloc_zfree(subreq);
- if (ret) {
- DEBUG(1, ("Failed to update LDB Cache for '%s' (%d)[%s] !?\n",
- data->pwd->pw_name, ret, strerror(ret)));
- proxy_return(data, ret, NULL);
- return;
+ goto fail;
}
- get_pw_entry(data->treq);
+fail:
+ ctx->ops.endpwent();
+ tevent_req_error(req, ret);
}
-static void enum_users(struct be_req *req)
-{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
- enum nss_status status;
- struct proxy_data *data;
-
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->pwd = talloc(data, struct passwd);
- if (!data->pwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
+/* =Getgrnam-wrapper======================================================*/
- status = ctx->ops.setpwent();
- if (status != NSS_STATUS_SUCCESS)
- return proxy_reply(req, EIO, "Operation failed");
-
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, "Operation failed");
- }
+static void get_gr_name_process(struct tevent_req *subreq);
+static void get_gr_name_remove_done(struct tevent_req *subreq);
+static void get_gr_name_add_done(struct tevent_req *subreq);
- tevent_req_set_callback(treq, get_pw_entry, data);
-}
-
-static void del_gr_gid_done(struct tevent_req *subreq);
-static void del_gr_gid(struct tevent_req *req)
+static struct tevent_req *get_gr_name_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ const char *name)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
- int ret;
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
- ret = sysdb_transaction_recv(req, data, &data->handle);
- if (ret) {
- return proxy_reply(data->req, ret, NULL);
- }
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
- subreq = sysdb_delete_group_by_gid_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->grp->gr_gid);
- if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
- }
- tevent_req_set_callback(subreq, del_gr_gid_done, data);
-}
+ memset(state, 0, sizeof(struct proxy_state));
-static void del_gr_gid_done(struct tevent_req *subreq)
-{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
- int ret;
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
+ state->name = name;
- ret = sysdb_delete_group_by_gid_recv(subreq);
- talloc_zfree(subreq);
- if (ret) {
- return proxy_return(data, ret, NULL);
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ talloc_zfree(req);
+ return NULL;
}
+ tevent_req_set_callback(subreq, get_gr_name_process, req);
- data->next_fn(data, EOK, NULL);
+ return req;
}
-static void set_gr_name_done(struct tevent_req *subreq);
-
-static void set_gr_name(struct tevent_req *req)
+static void get_gr_name_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
- struct tevent_req *subreq;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
+ enum nss_status status;
+ char *buffer;
+ char *newbuf;
+ size_t buflen;
+ bool delete_group = false;
int ret;
- ret = sysdb_transaction_recv(req, data, &data->handle);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
+ talloc_zfree(subreq);
- subreq = sysdb_store_group_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->grp->gr_name,
- data->grp->gr_gid,
- (const char **)data->grp->gr_mem);
- if (!subreq) {
- proxy_return(data, ret, NULL);
+ state->grp = talloc(state, struct group);
+ if (!state->grp) {
+ tevent_req_error(req, ENOMEM);
return;
}
- tevent_req_set_callback(subreq, set_gr_name_done, data);
-}
-
-static void set_gr_name_done(struct tevent_req *subreq)
-{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
- int ret;
- ret = sysdb_store_group_recv(subreq);
- talloc_zfree(subreq);
- if (ret) {
- proxy_return(data, ret, NULL);
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
return;
}
- data->next_fn(data, EOK, NULL);
-}
-
-static void get_gr_name(struct be_req *req, char *name)
-{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
- enum nss_status status;
- struct proxy_data *data;
- int ret;
-
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->grp = talloc(data, struct group);
- if (!data->grp)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- status = ctx->ops.getgrnam_r(name, data->grp,
- data->buffer, data->buflen, &ret);
+ /* FIXME: should we move this call outside the transaction to keep the
+ * transaction as short as possible ? */
+again:
+ status = ctx->ops.getgrnam_r(state->name, state->grp,
+ buffer, buflen, &ret);
switch (status) {
- case NSS_STATUS_NOTFOUND:
- data->dn = sysdb_group_dn(req->be_ctx->sysdb, data,
- req->be_ctx->domain->name, name);
- if (!data->dn)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
+ case NSS_STATUS_TRYAGAIN:
+ /* buffer too small ? */
+ if (buflen < MAX_BUF_SIZE) {
+ buflen *= 2;
+ }
+ if (buflen > MAX_BUF_SIZE) {
+ buflen = MAX_BUF_SIZE;
}
+ newbuf = talloc_realloc_size(state, buffer, buflen);
+ if (!newbuf) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ buffer = newbuf;
+ goto again;
- tevent_req_set_callback(treq, del_db_entry, data);
+ case NSS_STATUS_NOTFOUND:
+
+ delete_group = true;
break;
case NSS_STATUS_SUCCESS:
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
- /* FIXME: verify group does not have gid=0 as this is invalid */
- if (data->grp->gr_gid == 0) {
-
- tevent_req_set_callback(treq, del_db_entry, data);
+ /* gid=0 is an invalid value */
+ if (state->grp->gr_gid == 0) {
+ delete_group = true;
break;
}
- tevent_req_set_callback(treq, set_gr_name, data);
- break;
+ subreq = sysdb_store_group_send(state, state->ev, state->handle,
+ state->domain,
+ state->grp->gr_name,
+ state->grp->gr_gid,
+ (const char **)state->grp->gr_mem);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_gr_name_add_done, req);
+ return;
case NSS_STATUS_UNAVAIL:
/* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(req->be_ctx);
- return proxy_reply(req, EAGAIN, "Offline");
+ tevent_req_error(req, ENXIO);
+ return;
default:
- DEBUG(2, ("proxy -> getgrnam_r failed for '%s' (%d)[%s]\n",
- name, ret, strerror(ret)));
- return proxy_reply(req, ret, "Operation failed");
+ DEBUG(2, ("proxy -> getgrnam_r failed for '%s' <%d>\n",
+ state->name, status));
+ tevent_req_error(req, EIO);
+ return;
+ }
+
+ if (delete_group) {
+ struct ldb_dn *dn;
+
+ dn = sysdb_group_dn(state->sysdb, state,
+ state->domain->name, state->name);
+ if (!dn) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ subreq = sysdb_delete_entry_send(state, state->ev, state->handle, dn);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_gr_name_remove_done, req);
}
}
-static void get_gr_gid(struct be_req *req, gid_t gid)
+static void get_gr_name_add_done(struct tevent_req *subreq)
{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
- enum nss_status status;
- struct proxy_data *data;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
int ret;
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->grp = talloc(data, struct group);
- if (!data->grp)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ ret = sysdb_store_group_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+}
- status = ctx->ops.getgrgid_r(gid, data->grp,
- data->buffer, data->buflen, &ret);
+static void get_gr_name_remove_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ int ret;
- switch (status) {
- case NSS_STATUS_NOTFOUND:
- data->grp->gr_gid = gid;
+ ret = sysdb_delete_entry_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+}
- tevent_req_set_callback(treq, del_gr_gid, data);
- break;
+/* =Getgrgid-wrapper======================================================*/
- case NSS_STATUS_SUCCESS:
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
+static void get_gr_gid_process(struct tevent_req *subreq);
+static void get_gr_gid_remove_done(struct tevent_req *subreq);
- /* FIXME: verify group does not have gid=0 as this is invalid */
- if (data->grp->gr_gid == 0) {
- data->dn = sysdb_group_dn(req->be_ctx->sysdb, data,
- req->be_ctx->domain->name,
- data->grp->gr_name);
+static struct tevent_req *get_gr_gid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ gid_t gid)
+{
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
- tevent_req_set_callback(treq, del_db_entry, data);
- break;
- }
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
- tevent_req_set_callback(treq, set_gr_name, data);
- break;
+ memset(state, 0, sizeof(struct proxy_state));
- case NSS_STATUS_UNAVAIL:
- /* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(req->be_ctx);
- return proxy_reply(req, EAGAIN, "Offline");
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
+ state->gid = gid;
- default:
- DEBUG(2, ("proxy -> getgrgid_r failed for '%lu' (%d)[%s]\n",
- (unsigned long)gid, ret, strerror(ret)));
- return proxy_reply(req, ret, "Operation failed");
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ talloc_zfree(req);
+ return NULL;
}
-}
+ tevent_req_set_callback(subreq, get_gr_gid_process, req);
-static void get_gr_entry_store_done(struct tevent_req *subreq);
+ return req;
+}
-static void get_gr_entry(struct tevent_req *req)
+static void get_gr_gid_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(req,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
enum nss_status status;
- struct tevent_req *subreq;
- char *newb;
+ char *buffer;
+ char *newbuf;
+ size_t buflen;
+ bool delete_user = false;
int ret;
- data->treq = req;
-
- ret = sysdb_transaction_recv(req, data, &data->handle);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
if (ret) {
- return proxy_reply(data->req, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
+ }
+ talloc_zfree(subreq);
+
+ state->grp = talloc(state, struct group);
+ if (!state->grp) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
}
-retry:
- status = data->ctx->ops.getgrent_r(data->grp,
- data->buffer, data->buflen, &ret);
+again:
+ status = ctx->ops.getgrgid_r(state->gid, state->grp,
+ buffer, buflen, &ret);
switch (status) {
case NSS_STATUS_TRYAGAIN:
/* buffer too small ? */
- if (data->buflen < MAX_BUF_SIZE) {
- data->buflen *= 2;
+ if (buflen < MAX_BUF_SIZE) {
+ buflen *= 2;
}
- if (data->buflen > MAX_BUF_SIZE) {
- data->buflen = MAX_BUF_SIZE;
+ if (buflen > MAX_BUF_SIZE) {
+ buflen = MAX_BUF_SIZE;
}
- newb = talloc_realloc_size(data, data->buffer, data->buflen);
- if (!newb) {
- return proxy_return(data, ENOMEM, NULL);
+ newbuf = talloc_realloc_size(state, buffer, buflen);
+ if (!newbuf) {
+ tevent_req_error(req, ENOMEM);
+ return;
}
- data->buffer = newb;
- goto retry;
+ buffer = newbuf;
+ goto again;
case NSS_STATUS_NOTFOUND:
- data->ctx->ops.endgrent();
- data->next_fn(data, EOK, NULL);
+ delete_user = true;
break;
case NSS_STATUS_SUCCESS:
- /* FIXME: verify group does not have gid=0 as this is invalid */
- if (data->grp->gr_gid == 0) {
- goto retry;
+
+ /* gid=0 is an invalid value */
+ if (state->grp->gr_gid == 0) {
+ delete_user = true;
+ break;
}
- subreq = sysdb_store_group_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->grp->gr_name,
- data->grp->gr_gid,
- (const char **)data->grp->gr_mem);
+
+ subreq = sysdb_store_group_send(state, state->ev, state->handle,
+ state->domain,
+ state->grp->gr_name,
+ state->grp->gr_gid,
+ (const char **)state->grp->gr_mem);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ tevent_req_error(req, ENOMEM);
+ return;
}
- tevent_req_set_callback(subreq, get_gr_entry_store_done, data);
- break;
+ tevent_req_set_callback(subreq, get_gr_name_add_done, req);
+ return;
case NSS_STATUS_UNAVAIL:
/* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(data->req->be_ctx);
- return proxy_return(data, EAGAIN, NULL);
+ tevent_req_error(req, ENXIO);
+ return;
default:
- DEBUG(2, ("proxy -> getgrent_r failed (%d)[%s]\n",
- ret, strerror(ret)));
- proxy_return(data, ret, NULL);
+ DEBUG(2, ("proxy -> getgrgid_r failed for '%d' <%d>\n",
+ state->gid, status));
+ tevent_req_error(req, EIO);
+ return;
+ }
+
+ if (delete_user) {
+ subreq = sysdb_delete_group_by_gid_send(state, state->ev,
+ state->handle,
+ state->domain,
+ state->gid);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_gr_gid_remove_done, req);
}
}
-static void get_gr_entry_store_done(struct tevent_req *subreq)
+static void get_gr_gid_remove_done(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
int ret;
- ret = sysdb_store_group_recv(subreq);
+ ret = sysdb_delete_group_by_gid_recv(subreq);
talloc_zfree(subreq);
if (ret) {
- DEBUG(1, ("Failed to update LDB Cache for '%s' (%d)[%s] !?\n",
- data->grp->gr_name, ret, strerror(ret)));
- proxy_return(data, ret, NULL);
+ tevent_req_error(req, ret);
return;
}
- get_gr_entry(data->treq);
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
}
-static void enum_groups(struct be_req *req)
+/* =Getgrent-wrapper======================================================*/
+
+static void enum_groups_process(struct tevent_req *subreq);
+
+static struct tevent_req *enum_groups_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain)
{
- struct tevent_req *treq = NULL;
- struct proxy_ctx *ctx;
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
enum nss_status status;
- struct proxy_data *data;
-
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->grp = talloc(data, struct group);
- if (!data->grp)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
+
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
+
+ memset(state, 0, sizeof(struct proxy_state));
+
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
status = ctx->ops.setgrent();
- if (status != NSS_STATUS_SUCCESS)
- return proxy_reply(req, EIO, "Operation failed");
+ if (status != NSS_STATUS_SUCCESS) {
+ tevent_req_error(req, EIO);
+ goto fail;
+ }
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, "Operation failed");
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ goto fail;
}
+ tevent_req_set_callback(subreq, enum_groups_process, req);
- tevent_req_set_callback(treq, get_gr_entry, data);
+ return req;
+
+fail:
+ tevent_req_post(req, ev);
+ return req;
}
-static void get_gid_entry_store_done(struct tevent_req *subreq);
-static void get_gid_entry_del_done(struct tevent_req *subreq);
-static void get_gid_entry(struct proxy_data *data)
+static void enum_groups_process(struct tevent_req *subreq)
{
- struct tevent_req *subreq;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
enum nss_status status;
- char *newb;
+ char *buffer;
+ char *newbuf;
+ size_t buflen;
int ret;
-retry:
- status = data->ctx->ops.getgrgid_r(data->groups[data->cur], data->grp,
- data->buffer, data->buflen, &ret);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+ talloc_zfree(subreq);
+
+ state->grp = talloc(state, struct group);
+ if (!state->grp) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ /* getgrent is synchronous so instead of artifically wrapping it
+ * in fake async calls let's just loop here */
+
+again:
+ status = ctx->ops.getgrent_r(state->grp, buffer, buflen, &ret);
switch (status) {
case NSS_STATUS_TRYAGAIN:
/* buffer too small ? */
- if (data->buflen < MAX_BUF_SIZE) {
- data->buflen *= 2;
+ if (buflen < MAX_BUF_SIZE) {
+ buflen *= 2;
}
- if (data->buflen > MAX_BUF_SIZE) {
- data->buflen = MAX_BUF_SIZE;
+ if (buflen > MAX_BUF_SIZE) {
+ buflen = MAX_BUF_SIZE;
}
- newb = talloc_realloc_size(data, data->buffer, data->buflen);
- if (!newb) {
- return proxy_return(data, ENOMEM, NULL);
+ newbuf = talloc_realloc_size(state, buffer, buflen);
+ if (!newbuf) {
+ ret = ENOMEM;
+ goto fail;
}
- data->buffer = newb;
- goto retry;
+ buffer = newbuf;
+ goto again;
case NSS_STATUS_NOTFOUND:
- DEBUG(4, ("gid [%lu] not found, removing group\n",
- (unsigned long)(data->groups[data->cur])));
- subreq = sysdb_delete_group_by_gid_send(data, data->ev,
- data->handle,
- data->req->be_ctx->domain,
- data->groups[data->cur]);
+ /* we are done here */
+ ctx->ops.endgrent();
+ subreq = sysdb_transaction_commit_send(state, state->ev,
+ state->handle);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ tevent_req_error(req, ENOMEM);
+ return;
}
- tevent_req_set_callback(subreq, get_gid_entry_del_done, data);
- break;
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+ return;
case NSS_STATUS_SUCCESS:
- data->cur++;
- subreq = sysdb_store_group_send(data, data->ev, data->handle,
- data->req->be_ctx->domain,
- data->grp->gr_name,
- data->grp->gr_gid,
- (const char **)data->grp->gr_mem);
+ /* gid=0 is an invalid value */
+ if (state->grp->gr_gid == 0) {
+ goto again; /* skip */
+ }
+
+ subreq = sysdb_store_group_send(state, state->ev, state->handle,
+ state->domain,
+ state->grp->gr_name,
+ state->grp->gr_gid,
+ (const char **)state->grp->gr_mem);
if (!subreq) {
- proxy_return(data, ENOMEM, NULL);
+ tevent_req_error(req, ENOMEM);
+ return;
}
- tevent_req_set_callback(subreq, get_gid_entry_store_done, data);
- break;
+ /* SYNC WAIT: (polls until req is done) */
+ if (!tevent_req_poll(subreq, state->ev)) {
+ tevent_req_error(req, EFAULT);
+ return;
+ }
+ ret = sysdb_store_group_recv(subreq);
+
+ goto again; /* next one */
+
+ case NSS_STATUS_UNAVAIL:
+ /* "remote" backend unavailable. Enter offline mode */
+ ret = ENXIO;
+ goto fail;
default:
- DEBUG(2, ("proxy -> getgrgid_r failed (%d)[%s]\n",
+ DEBUG(2, ("proxy -> getgrent_r failed (%d)[%s]\n",
ret, strerror(ret)));
- proxy_return(data, ret, NULL);
+ goto fail;
}
+
+fail:
+ ctx->ops.endgrent();
+ tevent_req_error(req, ret);
}
-static void get_gid_entry_del_done(struct tevent_req *subreq)
+
+/* =Initgroups-wrapper====================================================*/
+
+static void get_initgr_process(struct tevent_req *subreq);
+static void get_initgr_groups_process(struct tevent_req *subreq);
+static void get_initgr_groups_done(struct tevent_req *subreq);
+static struct tevent_req *get_groups_by_gid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_handle *handle,
+ struct proxy_ctx *ctx,
+ struct sss_domain_info *domain,
+ gid_t *gids, int num_gids);
+static int get_groups_by_gid_recv(struct tevent_req *req);
+static void get_groups_by_gid_process(struct tevent_req *subreq);
+static struct tevent_req *get_group_from_gid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_handle *handle,
+ struct proxy_ctx *ctx,
+ struct sss_domain_info *domain,
+ gid_t gid);
+static int get_group_from_gid_recv(struct tevent_req *req);
+static void get_group_from_gid_send_del_done(struct tevent_req *subreq);
+static void get_group_from_gid_send_add_done(struct tevent_req *subreq);
+
+
+static struct tevent_req *get_initgr_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct proxy_ctx *ctx,
+ struct sysdb_ctx *sysdb,
+ struct sss_domain_info *domain,
+ const char *name)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
- int ret;
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
- ret = sysdb_delete_group_by_gid_recv(subreq);
- talloc_zfree(subreq);
- if (ret) {
- DEBUG(1, ("Failed to update LDB Cache for '%s' (%d)[%s] !?\n",
- data->grp->gr_name, ret, strerror(ret)));
- return proxy_return(data, ret, NULL);
- }
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
+
+ memset(state, 0, sizeof(struct proxy_state));
- data->cur++;
+ state->ev = ev;
+ state->ctx = ctx;
+ state->sysdb = sysdb;
+ state->domain = domain;
+ state->name = name;
- /* all done */
- if (data->cur == data->num) {
- return data->next_fn(data, EOK, NULL);
+ subreq = sysdb_transaction_send(state, state->ev, state->sysdb);
+ if (!subreq) {
+ talloc_zfree(req);
+ return NULL;
}
+ tevent_req_set_callback(subreq, get_initgr_process, req);
- /* next item */
- get_gid_entry(data);
+ return req;
}
-static void get_gid_entry_store_done(struct tevent_req *subreq)
+static void get_initgr_process(struct tevent_req *subreq)
{
- struct proxy_data *data = tevent_req_callback_data(subreq,
- struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
+ enum nss_status status;
+ char *buffer;
+ size_t buflen;
+ bool delete_user = false;
int ret;
- ret = sysdb_store_group_recv(subreq);
- talloc_zfree(subreq);
+ ret = sysdb_transaction_recv(subreq, state, &state->handle);
if (ret) {
- DEBUG(1, ("Failed to update LDB Cache for '%s' (%d)[%s] !?\n",
- data->grp->gr_name, ret, strerror(ret)));
- return proxy_return(data, ret, NULL);
+ tevent_req_error(req, ret);
+ return;
}
+ talloc_zfree(subreq);
- data->cur++;
+ state->pwd = talloc(state, struct passwd);
+ if (!state->pwd) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
- /* all done */
- if (data->cur == data->num) {
- return data->next_fn(data, EOK, NULL);
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ tevent_req_error(req, ENOMEM);
+ return;
}
- /* next item */
- get_gid_entry(data);
+ /* FIXME: should we move this call outside the transaction to keep the
+ * transaction as short as possible ? */
+ status = ctx->ops.getpwnam_r(state->name, state->pwd,
+ buffer, buflen, &ret);
+
+ switch (status) {
+ case NSS_STATUS_NOTFOUND:
+
+ delete_user = true;
+ break;
+
+ case NSS_STATUS_SUCCESS:
+
+ /* uid=0 or gid=0 are invalid values */
+ if (state->pwd->pw_uid == 0 || state->pwd->pw_gid == 0) {
+ delete_user = true;
+ break;
+ }
+
+ subreq = sysdb_store_user_send(state, state->ev, state->handle,
+ state->domain,
+ state->pwd->pw_name,
+ state->pwd->pw_passwd,
+ state->pwd->pw_uid,
+ state->pwd->pw_gid,
+ state->pwd->pw_gecos,
+ state->pwd->pw_dir,
+ state->pwd->pw_shell);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_initgr_groups_process, req);
+ return;
+
+ case NSS_STATUS_UNAVAIL:
+ /* "remote" backend unavailable. Enter offline mode */
+ tevent_req_error(req, ENXIO);
+ return;
+
+ default:
+ DEBUG(2, ("proxy -> getpwnam_r failed for '%s' <%d>\n",
+ state->name, status));
+ tevent_req_error(req, EIO);
+ return;
+ }
+
+ if (delete_user) {
+ struct ldb_dn *dn;
+
+ dn = sysdb_user_dn(state->sysdb, state,
+ state->domain->name, state->name);
+ if (!dn) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+
+ subreq = sysdb_delete_entry_send(state, state->ev, state->handle, dn);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_pw_name_remove_done, req);
+ }
}
-static void get_user_groups(void *pvt, int error, struct ldb_result *ignore)
+static void get_initgr_groups_process(struct tevent_req *subreq)
{
- struct proxy_data *data = talloc_get_type(pvt, struct proxy_data);
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ struct proxy_ctx *ctx = state->ctx;
enum nss_status status;
long int limit;
- long int start;
long int size;
long int num;
- char *name;
- gid_t gid;
+ long int num_gids;
+ gid_t *gids;
int ret;
- if (error != EOK) proxy_return(data, error, NULL);
- data->next_fn = proxy_return;
+ ret = sysdb_store_user_recv(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+ talloc_zfree(subreq);
- start = 0;
+ num_gids = 0;
limit = 4096;
num = 4096;
size = num*sizeof(gid_t);
- data->groups = talloc_size(data, size);
- if (!data->groups)
- return proxy_return(data, ENOMEM, NULL);
-
- gid = data->pwd->pw_gid;
- name = data->pwd->pw_name;
+ gids = talloc_size(state, size);
+ if (!gids) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
-retry:
- status = data->ctx->ops.initgroups_dyn(name, gid,
- &start, &num,
- &data->groups, limit, &ret);
+ state->gid = state->pwd->pw_gid;
+again:
+ /* FIXME: should we move this call outside the transaction to keep the
+ * transaction as short as possible ? */
+ status = ctx->ops.initgroups_dyn(state->name, state->gid, &num_gids,
+ &num, &gids, limit, &ret);
switch (status) {
case NSS_STATUS_TRYAGAIN:
/* buffer too small ? */
@@ -1339,113 +1655,311 @@ retry:
num = size/sizeof(gid_t);
}
limit = num;
- data->groups = talloc_realloc_size(data, data->groups, size);
- if (!data->groups) {
- return proxy_return(data, ENOMEM, NULL);
+ gids = talloc_realloc_size(state, gids, size);
+ if (!gids) {
+ tevent_req_error(req, ENOMEM);
+ return;
}
- goto retry;
+ goto again; /* retry with more memory */
case NSS_STATUS_SUCCESS:
- data->num = start;
DEBUG(4, ("User [%s] appears to be member of %lu groups\n",
- name, data->num));
- get_gid_entry(data);
+ state->name, num_gids));
+
+ subreq = get_groups_by_gid_send(state, state->ev, state->handle,
+ state->ctx, state->domain,
+ gids, num_gids);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_initgr_groups_done, req);
break;
default:
- DEBUG(2, ("proxy -> getgrent_r failed (%d)[%s]\n",
+ DEBUG(2, ("proxy -> initgroups_dyn failed (%d)[%s]\n",
ret, strerror(ret)));
- proxy_return(data, ret, NULL);
+ tevent_req_error(req, EIO);
+ return;
}
}
-static void get_initgr_user(struct be_req *req, char *name)
+static void get_initgr_groups_done(struct tevent_req *subreq)
{
- struct tevent_req *treq = NULL;
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct proxy_state *state = tevent_req_data(req,
+ struct proxy_state);
+ int ret;
+
+ ret = get_groups_by_gid_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+
+ subreq = sysdb_transaction_commit_send(state, state->ev, state->handle);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, proxy_default_done, req);
+}
+
+struct get_groups_state {
+ struct tevent_context *ev;
+ struct sysdb_handle *handle;
struct proxy_ctx *ctx;
+ struct sss_domain_info *domain;
+
+ gid_t *gids;
+ int num_gids;
+ int cur_gid;
+};
+
+static struct tevent_req *get_groups_by_gid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_handle *handle,
+ struct proxy_ctx *ctx,
+ struct sss_domain_info *domain,
+ gid_t *gids, int num_gids)
+{
+ struct tevent_req *req, *subreq;
+ struct get_groups_state *state;
+
+ req = tevent_req_create(mem_ctx, &state, struct get_groups_state);
+ if (!req) return NULL;
+
+ state->ev = ev;
+ state->handle = handle;
+ state->ctx = ctx;
+ state->domain = domain;
+ state->gids = gids;
+ state->num_gids = num_gids;
+ state->cur_gid = 0;
+
+ subreq = get_group_from_gid_send(state, ev, handle, ctx, domain, gids[0]);
+ if (!subreq) {
+ talloc_zfree(req);
+ return NULL;
+ }
+ tevent_req_set_callback(subreq, get_groups_by_gid_process, req);
+
+ return req;
+}
+
+static void get_groups_by_gid_process(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct get_groups_state *state = tevent_req_data(req,
+ struct get_groups_state);
+ int ret;
+
+ ret = get_group_from_gid_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+
+ state->cur_gid++;
+ if (state->cur_gid >= state->num_gids) {
+ tevent_req_done(req);
+ return;
+ }
+
+ subreq = get_group_from_gid_send(state,
+ state->ev, state->handle,
+ state->ctx, state->domain,
+ state->gids[state->cur_gid]);
+ if (!subreq) {
+ tevent_req_error(req, ENOMEM);
+ return;
+ }
+ tevent_req_set_callback(subreq, get_groups_by_gid_process, req);
+}
+
+static int get_groups_by_gid_recv(struct tevent_req *req)
+{
+ enum tevent_req_state tstate;
+ uint64_t err = 0;
+
+ if (tevent_req_is_error(req, &tstate, &err)) {
+ if (err != 0) return err;
+ return EIO;
+ }
+
+ return EOK;
+}
+
+static struct tevent_req *get_group_from_gid_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct sysdb_handle *handle,
+ struct proxy_ctx *ctx,
+ struct sss_domain_info *domain,
+ gid_t gid)
+{
+ struct tevent_req *req, *subreq;
+ struct proxy_state *state;
enum nss_status status;
- struct proxy_data *data;
+ char *buffer;
+ char *newbuf;
+ size_t buflen;
+ bool delete_user = false;
int ret;
- ctx = talloc_get_type(req->be_ctx->pvt_id_data, struct proxy_ctx);
-
- data = talloc_zero(req, struct proxy_data);
- if (!data)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->req = req;
- data->ctx = ctx;
- data->ev = req->be_ctx->ev;
- data->next_fn = proxy_return;
- data->pwd = talloc(data, struct passwd);
- if (!data->pwd)
- return proxy_reply(req, ENOMEM, "Out of memory");
- data->grp = talloc(data, struct group);
- if (!data->grp)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- data->buflen = 4096;
- data->buffer = talloc_size(data, data->buflen);
- if (!data->buffer)
- return proxy_reply(req, ENOMEM, "Out of memory");
-
- status = ctx->ops.getpwnam_r(name, data->pwd,
- data->buffer, data->buflen, &ret);
+ req = tevent_req_create(mem_ctx, &state, struct proxy_state);
+ if (!req) return NULL;
- switch (status) {
- case NSS_STATUS_NOTFOUND:
- data->dn = sysdb_user_dn(req->be_ctx->sysdb, data,
- req->be_ctx->domain->name, name);
- if (!data->dn)
- return proxy_reply(req, ENOMEM, "Out of memory");
+ memset(state, 0, sizeof(struct proxy_state));
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
+ state->ev = ev;
+ state->handle = handle;
+ state->ctx = ctx;
+ state->domain = domain;
+ state->gid = gid;
+
+ state->grp = talloc(state, struct group);
+ if (!state->grp) {
+ ret = ENOMEM;
+ goto fail;
+ }
+
+ buflen = DEFAULT_BUFSIZE;
+ buffer = talloc_size(state, buflen);
+ if (!buffer) {
+ ret = ENOMEM;
+ goto fail;
+ }
+
+again:
+ status = ctx->ops.getgrgid_r(state->gid, state->grp,
+ buffer, buflen, &ret);
+
+ switch (status) {
+ case NSS_STATUS_TRYAGAIN:
+ /* buffer too small ? */
+ if (buflen < MAX_BUF_SIZE) {
+ buflen *= 2;
}
+ if (buflen > MAX_BUF_SIZE) {
+ buflen = MAX_BUF_SIZE;
+ }
+ newbuf = talloc_realloc_size(state, buffer, buflen);
+ if (!newbuf) {
+ ret = ENOMEM;
+ goto fail;
+ }
+ buffer = newbuf;
+ goto again;
- tevent_req_set_callback(treq, del_db_entry, data);
+ case NSS_STATUS_NOTFOUND:
+
+ delete_user = true;
break;
case NSS_STATUS_SUCCESS:
- treq = sysdb_transaction_send(data, data->ev, req->be_ctx->sysdb);
- if (!treq) {
- return proxy_reply(req, ENOMEM, NULL);
- }
-
- /* FIXME: verify user does not have uid=0 or gid=0 as these are invalid
- * values */
- if (data->pwd->pw_uid == 0 || data->pwd->pw_gid == 0) {
- tevent_req_set_callback(treq, del_db_entry, data);
+ /* gid=0 is an invalid value */
+ if (state->grp->gr_gid == 0) {
+ delete_user = true;
break;
}
- if (ctx->ops.initgroups_dyn) {
- data->next_fn = get_user_groups;
-
- tevent_req_set_callback(treq, set_pw_name, data);
- } else {
- status = ctx->ops.setgrent();
- if (status != NSS_STATUS_SUCCESS)
- return proxy_reply(req, EIO, "Operation failed");
-
- tevent_req_set_callback(treq, get_gr_entry, data);
+ subreq = sysdb_store_group_send(state, state->ev, state->handle,
+ state->domain,
+ state->grp->gr_name,
+ state->grp->gr_gid,
+ (const char **)state->grp->gr_mem);
+ if (!subreq) {
+ ret = ENOMEM;
+ goto fail;
}
+ tevent_req_set_callback(subreq, get_group_from_gid_send_add_done, req);
break;
case NSS_STATUS_UNAVAIL:
/* "remote" backend unavailable. Enter offline mode */
- DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
- go_offline(req->be_ctx);
- return proxy_reply(req, EAGAIN, "Offline");
+ ret = ENXIO;
+ goto fail;
default:
- DEBUG(2, ("proxy -> getpwnam_r failed for '%s' (%d)[%s]\n",
- name, ret, strerror(ret)));
- return proxy_reply(req, ret, "Operation failed");
+ DEBUG(2, ("proxy -> getgrgid_r failed for '%d' <%d>\n",
+ state->gid, status));
+ ret = EIO;
+ goto fail;
+ }
+
+ if (delete_user) {
+ subreq = sysdb_delete_group_by_gid_send(state, state->ev,
+ state->handle,
+ state->domain,
+ state->gid);
+ if (!subreq) {
+ ret = ENOMEM;
+ goto fail;
+ }
+ tevent_req_set_callback(subreq, get_group_from_gid_send_del_done, req);
+ }
+
+ return req;
+
+fail:
+ tevent_req_error(req, ret);
+ tevent_req_post(req, ev);
+ return req;
+}
+
+static void get_group_from_gid_send_add_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ int ret;
+
+ ret = sysdb_store_group_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
+ }
+
+ tevent_req_done(req);
+}
+
+static void get_group_from_gid_send_del_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ int ret;
+
+ ret = sysdb_delete_entry_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ tevent_req_error(req, ret);
+ return;
}
+
+ tevent_req_done(req);
}
+static int get_group_from_gid_recv(struct tevent_req *req)
+{
+ enum tevent_req_state tstate;
+ uint64_t err = 0;
+
+ if (tevent_req_is_error(req, &tstate, &err)) {
+ if (err != 0) return err;
+ return EIO;
+ }
+
+ return EOK;
+}
+
+
+/* =Proxy_Id-Functions====================================================*/
+
/* TODO: actually do check something */
static void proxy_check_online(struct be_req *req)
{
@@ -1462,113 +1976,172 @@ static void proxy_check_online(struct be_req *req)
req->fn(req, EOK, NULL);
}
+static void proxy_get_account_info_done(struct tevent_req *subreq);
+
/* TODO: See if we can use async_req code */
-static void proxy_get_account_info(struct be_req *req)
+static void proxy_get_account_info(struct be_req *breq)
{
+ struct tevent_req *subreq;
struct be_acct_req *ar;
+ struct proxy_ctx *ctx;
+ struct tevent_context *ev;
+ struct sysdb_ctx *sysdb;
+ struct sss_domain_info *domain;
uid_t uid;
gid_t gid;
- ar = talloc_get_type(req->req_data, struct be_acct_req);
+ ar = talloc_get_type(breq->req_data, struct be_acct_req);
+ ctx = talloc_get_type(breq->be_ctx->pvt_id_data, struct proxy_ctx);
+ ev = breq->be_ctx->ev;
+ sysdb = breq->be_ctx->sysdb;
+ domain = breq->be_ctx->domain;
- if (is_offline(req->be_ctx)) {
- return proxy_reply(req, EAGAIN, "Offline");
+ if (is_offline(breq->be_ctx)) {
+ return proxy_reply(breq, EAGAIN, "Offline");
+ }
+
+ /* for now we support only core attrs */
+ if (ar->attr_type != BE_ATTR_CORE) {
+ return proxy_reply(breq, EINVAL, "Invalid attr type");
}
switch (ar->entry_type) {
case BE_REQ_USER: /* user */
switch (ar->filter_type) {
case BE_FILTER_NAME:
- switch (ar->attr_type) {
- case BE_ATTR_CORE:
- if (strchr(ar->filter_value, '*')) {
- return enum_users(req);
- } else {
- return get_pw_name(req, ar->filter_value);
+ if (strchr(ar->filter_value, '*')) {
+ subreq = enum_users_send(breq, ev, ctx,
+ sysdb, domain);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
}
- break;
- default:
- return proxy_reply(req, EINVAL, "Invalid attr type");
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
+ } else {
+ subreq = get_pw_name_send(breq, ev, ctx,
+ sysdb, domain,
+ ar->filter_value);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
+ }
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
}
break;
+
case BE_FILTER_IDNUM:
- switch (ar->attr_type) {
- case BE_ATTR_CORE:
- if (strchr(ar->filter_value, '*')) {
- return proxy_reply(req, EINVAL, "Invalid attr type");
- } else {
- char *endptr;
- errno = 0;
- uid = (uid_t)strtol(ar->filter_value, &endptr, 0);
- if (errno || *endptr || (ar->filter_value == endptr)) {
- return proxy_reply(req, EINVAL, "Invalid attr type");
- }
- return get_pw_uid(req, uid);
+ if (strchr(ar->filter_value, '*')) {
+ return proxy_reply(breq, EINVAL, "Invalid attr type");
+ } else {
+ char *endptr;
+ errno = 0;
+ uid = (uid_t)strtol(ar->filter_value, &endptr, 0);
+ if (errno || *endptr || (ar->filter_value == endptr)) {
+ return proxy_reply(breq, EINVAL, "Invalid attr type");
}
- break;
- default:
- return proxy_reply(req, EINVAL, "Invalid attr type");
+ subreq = get_pw_uid_send(breq, ev, ctx,
+ sysdb, domain, uid);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
+ }
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
}
break;
default:
- return proxy_reply(req, EINVAL, "Invalid filter type");
+ return proxy_reply(breq, EINVAL, "Invalid filter type");
}
break;
case BE_REQ_GROUP: /* group */
switch (ar->filter_type) {
case BE_FILTER_NAME:
- switch (ar->attr_type) {
- case BE_ATTR_CORE:
- if (strchr(ar->filter_value, '*')) {
- return enum_groups(req);
- } else {
- return get_gr_name(req, ar->filter_value);
+ if (strchr(ar->filter_value, '*')) {
+ subreq = enum_groups_send(breq, ev, ctx,
+ sysdb, domain);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
}
- break;
- default:
- return proxy_reply(req, EINVAL, "Invalid attr type");
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
+ } else {
+ subreq = get_gr_name_send(breq, ev, ctx,
+ sysdb, domain,
+ ar->filter_value);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
+ }
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
}
break;
case BE_FILTER_IDNUM:
- switch (ar->attr_type) {
- case BE_ATTR_CORE:
- if (strchr(ar->filter_value, '*')) {
- return proxy_reply(req, EINVAL, "Invalid attr type");
- } else {
- char *endptr;
- errno = 0;
- gid = (gid_t)strtol(ar->filter_value, &endptr, 0);
- if (errno || *endptr || (ar->filter_value == endptr)) {
- return proxy_reply(req, EINVAL, "Invalid attr type");
- }
- return get_gr_gid(req, gid);
+ if (strchr(ar->filter_value, '*')) {
+ return proxy_reply(breq, EINVAL, "Invalid attr type");
+ } else {
+ char *endptr;
+ errno = 0;
+ gid = (gid_t)strtol(ar->filter_value, &endptr, 0);
+ if (errno || *endptr || (ar->filter_value == endptr)) {
+ return proxy_reply(breq, EINVAL, "Invalid attr type");
}
- break;
- default:
- return proxy_reply(req, EINVAL, "Invalid attr type");
+ subreq = get_gr_gid_send(breq, ev, ctx,
+ sysdb, domain, gid);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
+ }
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
}
break;
default:
- return proxy_reply(req, EINVAL, "Invalid filter type");
+ return proxy_reply(breq, EINVAL, "Invalid filter type");
}
break;
case BE_REQ_INITGROUPS: /* init groups for user */
if (ar->filter_type != BE_FILTER_NAME) {
- return proxy_reply(req, EINVAL, "Invalid filter type");
- }
- if (ar->attr_type != BE_ATTR_CORE) {
- return proxy_reply(req, EINVAL, "Invalid attr type");
+ return proxy_reply(breq, EINVAL, "Invalid filter type");
}
if (strchr(ar->filter_value, '*')) {
- return proxy_reply(req, EINVAL, "Invalid filter value");
+ return proxy_reply(breq, EINVAL, "Invalid filter value");
}
- return get_initgr_user(req, ar->filter_value);
+ subreq = get_initgr_send(breq, ev, ctx, sysdb,
+ domain, ar->filter_value);
+ if (!subreq) {
+ return proxy_reply(breq, ENOMEM, "Out of memory");
+ }
+ tevent_req_set_callback(subreq,
+ proxy_get_account_info_done, breq);
+ return;
default: /*fail*/
- return proxy_reply(req, EINVAL, "Invalid request type");
+ break;
+ }
+
+ return proxy_reply(breq, EINVAL, "Invalid request type");
+}
+
+static void proxy_get_account_info_done(struct tevent_req *subreq)
+{
+ struct be_req *breq = tevent_req_callback_data(subreq,
+ struct be_req);
+ int ret;
+ ret = proxy_default_recv(subreq);
+ talloc_zfree(subreq);
+ if (ret) {
+ if (ret == ENXIO) {
+ DEBUG(2, ("proxy returned UNAVAIL error, going offline!\n"));
+ go_offline(breq->be_ctx);
+ }
}
+ proxy_reply(breq, ret, NULL);
}
static void proxy_shutdown(struct be_req *req)