summaryrefslogtreecommitdiffstats
path: root/src/tools
diff options
context:
space:
mode:
Diffstat (limited to 'src/tools')
-rw-r--r--src/tools/sss_cache.c360
1 files changed, 360 insertions, 0 deletions
diff --git a/src/tools/sss_cache.c b/src/tools/sss_cache.c
new file mode 100644
index 000000000..9eefca45a
--- /dev/null
+++ b/src/tools/sss_cache.c
@@ -0,0 +1,360 @@
+/*
+ SSSD
+
+ sss_cache
+
+ Copyright (C) Jan Zeleny <jzeleny@redhat.com> 2011
+
+ 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
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <talloc.h>
+#include <popt.h>
+#include <sys/types.h>
+
+#include "util/util.h"
+#include "tools/sss_sync_ops.h"
+#include "db/sysdb.h"
+
+#define INVALIDATE_NONE 0
+#define INVALIDATE_USERS 1
+#define INVALIDATE_GROUPS 2
+#define INVALIDATE_NETGROUPS 4
+
+#define TYPE_USER 0
+#define TYPE_GROUP 1
+#define TYPE_NETGROUP 2
+struct entry_type_t {
+ const char *type_string;
+ int (* search_fn)(TALLOC_CTX *, struct sysdb_ctx *, struct sss_domain_info *,
+ const char *, const char **, size_t *, struct ldb_message ***);
+};
+static struct entry_type_t entry_types[] = {
+ {"user", sysdb_search_users},
+ {"group", sysdb_search_groups},
+ {"netgroup", sysdb_search_netgroups}
+};
+
+struct cache_tool_ctx {
+ struct confdb_ctx *confdb;
+ struct sss_domain_info *domains;
+ struct sysdb_ctx_list *sysdb_list;
+
+ char *user_filter;
+ char *group_filter;
+ char *netgroup_filter;
+};
+
+errno_t init_domains(struct cache_tool_ctx *ctx, const char *domain);
+errno_t init_context(int argc, const char *argv[], struct cache_tool_ctx **tctx);
+errno_t invalidate_entry(TALLOC_CTX *ctx, struct sysdb_ctx *sysdb,
+ const char *name, int entry_type);
+void invalidate_entries(TALLOC_CTX *ctx, struct sysdb_ctx *sysdb,
+ int entry_type, const char *filter);
+
+int main(int argc, const char *argv[])
+{
+ errno_t ret;
+ struct cache_tool_ctx *tctx = NULL;
+ struct sysdb_ctx *sysdb;
+ int i;
+
+ ret = init_context(argc, argv, &tctx);
+ if (ret != EOK) {
+ DEBUG(2, ("Error initializing context for the application\n"));
+ goto done;
+ }
+
+ for (i = 0; i < tctx->sysdb_list->num_dbs; i++) {
+ sysdb = tctx->sysdb_list->dbs[i];
+ ret = sysdb_transaction_start(sysdb);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not start the transaction!\n"));
+ goto done;
+ }
+
+ invalidate_entries(tctx, sysdb, TYPE_USER, tctx->user_filter);
+ invalidate_entries(tctx, sysdb, TYPE_GROUP, tctx->group_filter);
+ invalidate_entries(tctx, sysdb, TYPE_NETGROUP, tctx->netgroup_filter);
+
+ ret = sysdb_transaction_commit(sysdb);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not commit the transaction!\n"));
+ sysdb_transaction_cancel(sysdb);
+ }
+ }
+
+done:
+ if (tctx) talloc_free(tctx);
+ return ret;
+}
+
+
+void invalidate_entries(TALLOC_CTX *ctx, struct sysdb_ctx *sysdb,
+ int entry_type, const char *filter)
+{
+ const char *attrs[] = {SYSDB_NAME, NULL};
+ size_t msg_count;
+ struct ldb_message **msgs;
+ struct entry_type_t type_rec;
+ errno_t ret;
+ int i;
+ const char *c_name;
+
+ type_rec = entry_types[entry_type];
+ if (filter) {
+ ret = type_rec.search_fn(ctx, sysdb, NULL, filter, attrs,
+ &msg_count, &msgs);
+ if (ret != EOK) {
+ DEBUG(3, ("Searching for %s with filter %s failed\n",
+ type_rec.type_string, filter));
+ return;
+ }
+
+ for (i = 0; i < msg_count; i++) {
+ c_name = ldb_msg_find_attr_as_string(msgs[i], SYSDB_NAME, NULL);
+ if (c_name == NULL) {
+ DEBUG(3, ("Something bad happened, can't find attribute %s",
+ SYSDB_NAME));
+ ERROR("Couldn't invalidate %s", type_rec.type_string);
+ } else {
+ ret = invalidate_entry(ctx, sysdb, c_name, entry_type);
+ if (ret != EOK) {
+ DEBUG(3, ("Couldn't invalidate %s %s", type_rec.type_string,
+ c_name));
+ ERROR("Couldn't invalidate %s %s", type_rec.type_string,
+ c_name);
+ }
+ }
+ }
+ talloc_zfree(msgs);
+ }
+}
+
+errno_t invalidate_entry(TALLOC_CTX *ctx, struct sysdb_ctx *sysdb,
+ const char *name, int entry_type)
+{
+ struct sysdb_attrs *sys_attrs = NULL;
+ errno_t ret;
+
+ sys_attrs = sysdb_new_attrs(ctx);
+ if (sys_attrs) {
+ ret = sysdb_attrs_add_time_t(sys_attrs,
+ SYSDB_CACHE_EXPIRE, 1);
+ if (ret == EOK) {
+ switch (entry_type) {
+ case TYPE_USER:
+ ret = sysdb_set_user_attr(ctx, sysdb, NULL, name,
+ sys_attrs, SYSDB_MOD_REP);
+ break;
+ case TYPE_GROUP:
+ ret = sysdb_set_group_attr(ctx, sysdb, NULL, name,
+ sys_attrs, SYSDB_MOD_REP);
+ break;
+ case TYPE_NETGROUP:
+ ret = sysdb_set_netgroup_attr(sysdb, NULL, name,
+ sys_attrs, SYSDB_MOD_REP);
+ break;
+ default:
+ return EINVAL;
+ }
+ if (ret != EOK) {
+ DEBUG(3, ("Could not set entry attributes\n"));
+ }
+ } else {
+ DEBUG(3, ("Could not add expiration time to attributes\n"));
+ }
+ talloc_zfree(sys_attrs);
+ } else {
+ DEBUG(3, ("Could not create sysdb attributes\n"));
+ }
+ return ret;
+}
+
+errno_t init_domains(struct cache_tool_ctx *ctx, const char *domain) {
+ char *confdb_path;
+ int ret;
+ struct sysdb_ctx *db_ctx = NULL;
+
+ confdb_path = talloc_asprintf(ctx, "%s/%s", DB_PATH, CONFDB_FILE);
+ if (confdb_path == NULL) {
+ return ENOMEM;
+ }
+
+ /* Connect to the conf db */
+ ret = confdb_init(ctx, &ctx->confdb, confdb_path);
+ talloc_free(confdb_path);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not initialize connection to the confdb\n"));
+ return ret;
+ }
+
+ if (domain) {
+ ret = confdb_get_domain(ctx->confdb, domain, &ctx->domains);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not get '%s' domain: [%d] [%s]\n",
+ domain, ret, strerror(ret)));
+ goto fail;
+ }
+
+ ret = sysdb_domain_init(ctx, ctx->domains, DB_PATH, &db_ctx);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not initialize connection to the sysdb\n"));
+ goto fail;
+ }
+
+ ret = sysdb_list_init(ctx, DB_PATH, db_ctx, &ctx->sysdb_list);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not initialize the list of connections\n"));
+ goto fail;
+ }
+ } else {
+ ret = sysdb_init(ctx, ctx->confdb, NULL, false, &ctx->sysdb_list);
+ if (ret != EOK) {
+ DEBUG(1, ("Could not initialize connection to the sysdb\n"));
+ goto fail;
+ }
+ }
+
+ return EOK;
+fail:
+ if (ctx->confdb) talloc_zfree(ctx->confdb);
+ if (ctx->domains) talloc_zfree(ctx->domains);
+ if (ctx->sysdb_list) {
+ talloc_zfree(ctx->sysdb_list);
+ } else {
+ if (db_ctx) talloc_free(db_ctx);
+ }
+ return ret;
+}
+
+errno_t init_context(int argc, const char *argv[], struct cache_tool_ctx **tctx)
+{
+ struct cache_tool_ctx *ctx = NULL;
+ int idb = INVALIDATE_NONE;
+ char *user = NULL;
+ char *group = NULL;
+ char *netgroup = NULL;
+ char *domain = NULL;
+ int debug = 0;
+ errno_t ret = EOK;
+
+ poptContext pc = NULL;
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ { "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &debug,
+ 0, _("The debug level to run with"), NULL },
+ { "user", 'u', POPT_ARG_STRING, &user, 0,
+ _("Invalidate particular user"), NULL },
+ { "users", 'U', POPT_ARG_NONE, NULL, 'u',
+ _("Invalidate all users"), NULL },
+ { "group", 'g', POPT_ARG_STRING, &group, 0,
+ _("Invalidate particular group"), NULL },
+ { "groups", 'G', POPT_ARG_NONE, NULL, 'g',
+ _("Invalidate all groups"), NULL },
+ { "netgroup", 'n', POPT_ARG_STRING, &netgroup, 0,
+ _("Invalidate particular netgroup"), NULL },
+ { "netgroups", 'N', POPT_ARG_NONE, NULL, 'n',
+ _("Invalidate all netgroups"), NULL },
+ { "domain", 'd', POPT_ARG_STRING, &domain, 0,
+ _("Only invalidate entries from a particular domain"), NULL },
+ POPT_TABLEEND
+ };
+
+ ret = set_locale();
+ if (ret != EOK) {
+ DEBUG(1, ("set_locale failed (%d): %s\n", ret, strerror(ret)));
+ ERROR("Error setting the locale\n");
+ goto fini;
+ }
+
+ pc = poptGetContext(NULL, argc, argv, long_options, 0);
+ while ((ret = poptGetNextOpt(pc)) > 0) {
+ switch (ret) {
+ case 'u':
+ idb |= INVALIDATE_USERS;
+ break;
+ case 'g':
+ idb |= INVALIDATE_GROUPS;
+ break;
+ case 'n':
+ idb |= INVALIDATE_NETGROUPS;
+ break;
+ }
+ }
+ if (ret != -1) {
+ BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini);
+ }
+
+ debug_level = debug;
+ debug_prg_name = argv[0];
+ CHECK_ROOT(ret, debug_prg_name);
+
+ ctx = talloc_zero(NULL, struct cache_tool_ctx);
+ if (ctx == NULL) {
+ DEBUG(1, ("Could not allocate memory for tools context\n"));
+ ret = ENOMEM;
+ goto fini;
+ }
+
+ if (idb & INVALIDATE_USERS) {
+ ctx->user_filter = talloc_asprintf(ctx, "(%s=*)", SYSDB_NAME);
+ } else if (user) {
+ ctx->user_filter = talloc_asprintf(ctx, "(%s=%s)", SYSDB_NAME, user);
+ }
+
+ if (idb & INVALIDATE_GROUPS) {
+ ctx->group_filter = talloc_asprintf(ctx, "(%s=*)", SYSDB_NAME);
+ } else if (group) {
+ ctx->group_filter = talloc_asprintf(ctx, "(%s=%s)", SYSDB_NAME, group);
+ }
+
+ if (idb & INVALIDATE_NETGROUPS) {
+ ctx->netgroup_filter = talloc_asprintf(ctx, "(%s=*)", SYSDB_NAME);
+ } else if (netgroup) {
+ ctx->netgroup_filter = talloc_asprintf(ctx, "(%s=%s)", SYSDB_NAME,
+ netgroup);
+ }
+ if (((idb & INVALIDATE_USERS || user) && !ctx->user_filter) ||
+ ((idb & INVALIDATE_GROUPS || group) && !ctx->group_filter) ||
+ ((idb & INVALIDATE_NETGROUPS || netgroup) && !ctx->netgroup_filter)) {
+ DEBUG(1, ("Construction of filters failed\n"));
+ ret = ENOMEM;
+ goto fini;
+ }
+
+ ret = init_domains(ctx, domain);
+ if (ret != EOK) {
+ DEBUG(3, ("Initialization of sysdb connections failed\n"));
+ goto fini;
+ }
+
+ ret = EOK;
+
+fini:
+ poptFreeContext(pc);
+ free(user);
+ free(group);
+ free(netgroup);
+ free(domain);
+ if (ret != EOK && ctx) {
+ talloc_zfree(ctx);
+ }
+ if (ret == EOK) {
+ *tctx = ctx;
+ }
+ return ret;
+}