[SSSD] [PATCH] Update memcache after changes to group memberships in LOCAL domain

Jakub Hrozek jhrozek at redhat.com
Tue Jan 15 13:41:33 UTC 2013


The attached patches fix https://fedorahosted.org/sssd/ticket/1764. We
were only invalidating memcache when removing users or groups, but we
should invalidate it on any changes including changes to group
memberships etc.
-------------- next part --------------
>From 3f010184531e7ab2974fca86cc43edc6a2c8c0ed Mon Sep 17 00:00:00 2001
From: Jakub Hrozek <jhrozek at redhat.com>
Date: Tue, 15 Jan 2013 09:20:47 +0100
Subject: [PATCH 1/4] TOOLS: move memcache related functions to
 tools_mc_utils.c

The upcoming patches will link only users of this file with client libs,
so it's better to have it separate.

There is no functional change in this patch
---
 Makefile.am               |   1 +
 src/tools/tools_mc_util.c | 187 ++++++++++++++++++++++++++++++++++++++++++++++
 src/tools/tools_util.c    | 161 ---------------------------------------
 src/tools/tools_util.h    |   1 +
 4 files changed, 189 insertions(+), 161 deletions(-)
 create mode 100644 src/tools/tools_mc_util.c

diff --git a/Makefile.am b/Makefile.am
index 98d8bba3f8cd9cf031332e9371ab36023d721347..8c9cd32ea2218827b857ec77712ea6125f9506bb 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -285,6 +285,7 @@ SSSD_RESPONDER_OBJ = \
 SSSD_TOOLS_OBJ = \
     src/tools/sss_sync_ops.c \
     src/tools/tools_util.c \
+    src/tools/tools_mc_util.c \
     src/tools/files.c \
     src/tools/selinux.c \
     src/tools/nscd.c
diff --git a/src/tools/tools_mc_util.c b/src/tools/tools_mc_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..5348829eb51389f920d415ab53b55ce6698843e6
--- /dev/null
+++ b/src/tools/tools_mc_util.c
@@ -0,0 +1,187 @@
+/*
+   SSSD
+
+   tools_mc_util - interface to the memcache for userspace tools
+
+   Copyright (C) Red Hat                                        2013
+
+   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 <talloc.h>
+#include <fcntl.h>
+
+#include "util/util.h"
+#include "tools/tools_util.h"
+#include "util/mmap_cache.h"
+
+static errno_t sss_mc_set_recycled(int fd)
+{
+    uint32_t w = SSS_MC_HEADER_RECYCLED;
+    struct sss_mc_header h;
+    off_t offset;
+    off_t pos;
+    int ret;
+
+
+    offset = MC_PTR_DIFF(&h.status, &h);
+
+    pos = lseek(fd, offset, SEEK_SET);
+    if (pos == -1) {
+        /* What do we do now ? */
+        return errno;
+    }
+
+    errno = 0;
+    ret = sss_atomic_write_s(fd, (uint8_t *)&w, sizeof(h.status));
+    if (ret == -1) {
+        return errno;
+    }
+
+    if (ret != sizeof(h.status)) {
+        /* Write error */
+        return EIO;
+    }
+
+    return EOK;
+}
+
+errno_t sss_memcache_invalidate(const char *mc_filename)
+{
+    int mc_fd = -1;
+    errno_t ret;
+    errno_t pret;
+    useconds_t t = 50000;
+    int retries = 2;
+
+    if (!mc_filename) {
+        return EINVAL;
+    }
+
+    mc_fd = open(mc_filename, O_RDWR);
+    if (mc_fd == -1) {
+        ret = errno;
+        if (ret == ENOENT) {
+            DEBUG(SSSDBG_TRACE_FUNC,("Memory cache file %s "
+                  "does not exist.\n", mc_filename));
+            return EOK;
+        } else {
+            DEBUG(SSSDBG_CRIT_FAILURE, ("Unable to open file %s: %s\n",
+                  mc_filename, strerror(ret)));
+            return ret;
+        }
+    }
+
+    ret = sss_br_lock_file(mc_fd, 0, 1, retries, t);
+    if (ret == EACCES) {
+        DEBUG(SSSDBG_TRACE_FUNC,
+              ("File %s already locked by someone else.\n", mc_filename));
+        goto done;
+    } else if (ret != EOK) {
+       DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to lock file %s.\n", mc_filename));
+       goto done;
+    }
+    /* Mark the mc file as recycled. */
+    ret = sss_mc_set_recycled(mc_fd);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to mark memory cache file %s "
+              "as recycled.\n", mc_filename));
+        goto done;
+    }
+
+    ret = EOK;
+done:
+    if (mc_fd != -1) {
+        /* Closing the file also releases the lock */
+        close(mc_fd);
+
+        /* Only unlink the file if invalidation was succesful */
+        if (ret == EOK) {
+            pret = unlink(mc_filename);
+            if (pret == -1) {
+                DEBUG(SSSDBG_MINOR_FAILURE,
+                      ("Failed to unlink file %s. "
+                       "Will be unlinked later by sssd_nss.\n"));
+            }
+        }
+    }
+    return ret;
+}
+
+static int clear_fastcache(bool *sssd_nss_is_off)
+{
+    int ret;
+    ret = sss_memcache_invalidate(SSS_NSS_MCACHE_DIR"/passwd");
+    if (ret != EOK) {
+        if (ret == EACCES) {
+            *sssd_nss_is_off = false;
+            return EOK;
+        } else {
+            return ret;
+        }
+    }
+
+    ret = sss_memcache_invalidate(SSS_NSS_MCACHE_DIR"/group");
+    if (ret != EOK) {
+        if (ret == EACCES) {
+            *sssd_nss_is_off = false;
+            return EOK;
+        } else {
+            return ret;
+        }
+    }
+
+    *sssd_nss_is_off = true;
+    return EOK;
+}
+
+errno_t sss_memcache_clear_all(void)
+{
+    errno_t ret;
+    bool sssd_nss_is_off = false;
+    FILE *clear_mc_flag;
+
+    ret = clear_fastcache(&sssd_nss_is_off);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to clear caches.\n"));
+        return EIO;
+    }
+    if (!sssd_nss_is_off) {
+        /* sssd_nss is running -> signal monitor to invalidate fastcache */
+        clear_mc_flag = fopen(SSS_NSS_MCACHE_DIR"/"CLEAR_MC_FLAG, "w");
+        if (clear_mc_flag == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE,
+                  ("Failed to create clear_mc_flag file. "
+                   "Memory cache will not be cleared.\n"));
+            return EIO;
+        }
+        ret = fclose(clear_mc_flag);
+        if (ret != 0) {
+            ret = errno;
+            DEBUG(SSSDBG_CRIT_FAILURE,
+                  ("Unable to close file descriptor: %s\n",
+                   strerror(ret)));
+            return EIO;
+        }
+        DEBUG(SSSDBG_TRACE_FUNC, ("Sending SIGHUP to monitor.\n"));
+        ret = signal_sssd(SIGHUP);
+        if (ret != EOK) {
+            DEBUG(SSSDBG_CRIT_FAILURE,
+                  ("Failed to send SIGHUP to monitor.\n"));
+            return EIO;
+        }
+    }
+
+    return EOK;
+}
diff --git a/src/tools/tools_util.c b/src/tools/tools_util.c
index 9bb254572341922442c1892247f398532414814d..c27b88a1968f86bfc89c0b6b82083ca5fc94e000 100644
--- a/src/tools/tools_util.c
+++ b/src/tools/tools_util.c
@@ -35,7 +35,6 @@
 #include "db/sysdb.h"
 #include "tools/tools_util.h"
 #include "tools/sss_sync_ops.h"
-#include "util/mmap_cache.h"
 
 static int setup_db(struct tools_ctx *ctx)
 {
@@ -674,163 +673,3 @@ errno_t signal_sssd(int signum)
 
     return EOK;
 }
-
-static errno_t sss_mc_set_recycled(int fd)
-{
-    uint32_t w = SSS_MC_HEADER_RECYCLED;
-    struct sss_mc_header h;
-    off_t offset;
-    off_t pos;
-    int ret;
-
-
-    offset = MC_PTR_DIFF(&h.status, &h);
-
-    pos = lseek(fd, offset, SEEK_SET);
-    if (pos == -1) {
-        /* What do we do now ? */
-        return errno;
-    }
-
-    errno = 0;
-    ret = sss_atomic_write_s(fd, (uint8_t *)&w, sizeof(h.status));
-    if (ret == -1) {
-        return errno;
-    }
-
-    if (ret != sizeof(h.status)) {
-        /* Write error */
-        return EIO;
-    }
-
-    return EOK;
-}
-
-errno_t sss_memcache_invalidate(const char *mc_filename)
-{
-    int mc_fd = -1;
-    errno_t ret;
-    errno_t pret;
-    useconds_t t = 50000;
-    int retries = 2;
-
-    if (!mc_filename) {
-        return EINVAL;
-    }
-
-    mc_fd = open(mc_filename, O_RDWR);
-    if (mc_fd == -1) {
-        ret = errno;
-        if (ret == ENOENT) {
-            DEBUG(SSSDBG_TRACE_FUNC,("Memory cache file %s "
-                  "does not exist.\n", mc_filename));
-            return EOK;
-        } else {
-            DEBUG(SSSDBG_CRIT_FAILURE, ("Unable to open file %s: %s\n",
-                  mc_filename, strerror(ret)));
-            return ret;
-        }
-    }
-
-    ret = sss_br_lock_file(mc_fd, 0, 1, retries, t);
-    if (ret == EACCES) {
-        DEBUG(SSSDBG_TRACE_FUNC,
-              ("File %s already locked by someone else.\n", mc_filename));
-        goto done;
-    } else if (ret != EOK) {
-       DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to lock file %s.\n", mc_filename));
-       goto done;
-    }
-    /* Mark the mc file as recycled. */
-    ret = sss_mc_set_recycled(mc_fd);
-    if (ret != EOK) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to mark memory cache file %s "
-              "as recycled.\n", mc_filename));
-        goto done;
-    }
-
-    ret = EOK;
-done:
-    if (mc_fd != -1) {
-        /* Closing the file also releases the lock */
-        close(mc_fd);
-
-        /* Only unlink the file if invalidation was succesful */
-        if (ret == EOK) {
-            pret = unlink(mc_filename);
-            if (pret == -1) {
-                DEBUG(SSSDBG_MINOR_FAILURE,
-                      ("Failed to unlink file %s. "
-                       "Will be unlinked later by sssd_nss.\n"));
-            }
-        }
-    }
-    return ret;
-}
-
-static int clear_fastcache(bool *sssd_nss_is_off)
-{
-    int ret;
-    ret = sss_memcache_invalidate(SSS_NSS_MCACHE_DIR"/passwd");
-    if (ret != EOK) {
-        if (ret == EACCES) {
-            *sssd_nss_is_off = false;
-            return EOK;
-        } else {
-            return ret;
-        }
-    }
-
-    ret = sss_memcache_invalidate(SSS_NSS_MCACHE_DIR"/group");
-    if (ret != EOK) {
-        if (ret == EACCES) {
-            *sssd_nss_is_off = false;
-            return EOK;
-        } else {
-            return ret;
-        }
-    }
-
-    *sssd_nss_is_off = true;
-    return EOK;
-}
-
-errno_t sss_memcache_clear_all(void)
-{
-    errno_t ret;
-    bool sssd_nss_is_off = false;
-    FILE *clear_mc_flag;
-
-    ret = clear_fastcache(&sssd_nss_is_off);
-    if (ret != EOK) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to clear caches.\n"));
-        return EIO;
-    }
-    if (!sssd_nss_is_off) {
-        /* sssd_nss is running -> signal monitor to invalidate fastcache */
-        clear_mc_flag = fopen(SSS_NSS_MCACHE_DIR"/"CLEAR_MC_FLAG, "w");
-        if (clear_mc_flag == NULL) {
-            DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Failed to create clear_mc_flag file. "
-                   "Memory cache will not be cleared.\n"));
-            return EIO;
-        }
-        ret = fclose(clear_mc_flag);
-        if (ret != 0) {
-            ret = errno;
-            DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Unable to close file descriptor: %s\n",
-                   strerror(ret)));
-            return EIO;
-        }
-        DEBUG(SSSDBG_TRACE_FUNC, ("Sending SIGHUP to monitor.\n"));
-        ret = signal_sssd(SIGHUP);
-        if (ret != EOK) {
-            DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Failed to send SIGHUP to monitor.\n"));
-            return EIO;
-        }
-    }
-
-    return EOK;
-}
diff --git a/src/tools/tools_util.h b/src/tools/tools_util.h
index 20a2a4af28621dce53cd57822b8b9c1a69d4a6b2..aa55bfaf32386c3a3a2107219b26245b91ab97f8 100644
--- a/src/tools/tools_util.h
+++ b/src/tools/tools_util.h
@@ -104,6 +104,7 @@ int run_userdel_cmd(struct tools_ctx *tctx);
 
 errno_t signal_sssd(int signum);
 
+/* tools_mc_util.c */
 errno_t sss_memcache_invalidate(const char *mc_filename);
 
 errno_t sss_memcache_clear_all(void);
-- 
1.8.0.2

-------------- next part --------------
>From f70fdbc366630ecf458eafc2e89278591cf111a6 Mon Sep 17 00:00:00 2001
From: Jakub Hrozek <jhrozek at redhat.com>
Date: Tue, 15 Jan 2013 11:40:19 +0100
Subject: [PATCH 2/4] TOOLS: Split querying nss responder into a separate
 function

The tools query the responder in order to sync the memcache after
performing changes to the local database. The functions will be reused
by other tools so I split them into a separate functions.
---
 Makefile.am               | 17 ++++++++++------
 src/tools/sss_groupdel.c  | 22 ++++++---------------
 src/tools/sss_userdel.c   | 20 ++++---------------
 src/tools/tools_mc_util.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++
 src/tools/tools_util.h    |  3 +++
 5 files changed, 73 insertions(+), 38 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 8c9cd32ea2218827b857ec77712ea6125f9506bb..710c10168d2665ce92b56fe792e88c6c1076911b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -285,11 +285,15 @@ SSSD_RESPONDER_OBJ = \
 SSSD_TOOLS_OBJ = \
     src/tools/sss_sync_ops.c \
     src/tools/tools_util.c \
-    src/tools/tools_mc_util.c \
     src/tools/files.c \
     src/tools/selinux.c \
     src/tools/nscd.c
 
+SSSD_LCL_TOOLS_OBJ = \
+    src/sss_client/common.c \
+    src/tools/tools_mc_util.c \
+    $(SSSD_TOOLS_OBJ)
+
 SSSD_RESOLV_OBJ = \
     src/resolv/async_resolv.c
 if BUILD_ARES_DATA
@@ -684,10 +688,9 @@ sss_useradd_LDADD = \
     $(TOOLS_LIBS)
 
 sss_userdel_SOURCES = \
-    src/sss_client/common.c \
     src/tools/sss_userdel.c \
     src/util/find_uid.c \
-    $(SSSD_TOOLS_OBJ)
+    $(SSSD_LCL_TOOLS_OBJ)
 sss_userdel_LDADD = \
     libsss_util.la \
     $(TOOLS_LIBS)
@@ -703,9 +706,8 @@ sss_groupadd_LDADD = \
     $(TOOLS_LIBS)
 
 sss_groupdel_SOURCES = \
-    src/sss_client/common.c \
     src/tools/sss_groupdel.c \
-    $(SSSD_TOOLS_OBJ)
+    $(SSSD_LCL_TOOLS_OBJ)
 sss_groupdel_LDADD = \
     libsss_util.la \
     $(TOOLS_LIBS)
@@ -736,10 +738,13 @@ sss_groupshow_LDADD = \
 
 sss_cache_SOURCES = \
     src/tools/sss_cache.c \
-    $(SSSD_TOOLS_OBJ)
+    $(SSSD_LCL_TOOLS_OBJ)
 sss_cache_LDADD = \
     libsss_util.la \
     $(TOOLS_LIBS)
+sss_cache_CFLAGS = $(AM_CFLAGS)
+sss_cache_LDFLAGS = \
+    $(CLIENT_LIBS)
 
 sss_debuglevel_SOURCES = \
     src/tools/sss_debuglevel.c \
diff --git a/src/tools/sss_groupdel.c b/src/tools/sss_groupdel.c
index 66ea292604316a28cbd35170b3a7fc3af6bbdbef..456b2b48866e1517edda05b8f1ec9db9c150e68d 100644
--- a/src/tools/sss_groupdel.c
+++ b/src/tools/sss_groupdel.c
@@ -29,7 +29,6 @@
 #include "util/util.h"
 #include "tools/tools_util.h"
 #include "tools/sss_sync_ops.h"
-#include "sss_client/sss_cli.h"
 
 int main(int argc, const char **argv)
 {
@@ -37,10 +36,6 @@ int main(int argc, const char **argv)
     int pc_debug = SSSDBG_DEFAULT;
     const char *pc_groupname = NULL;
     struct tools_ctx *tctx = NULL;
-    struct sss_cli_req_data rd;
-    uint8_t *repbuf = NULL;
-    size_t replen;
-    enum nss_status nret;
 
     poptContext pc = NULL;
     struct poptOption long_options[] = {
@@ -116,17 +111,12 @@ int main(int argc, const char **argv)
         goto done;
     }
 
-    rd.data = pc_groupname;
-    rd.len = strlen(pc_groupname) + 1;
-
-    sss_nss_lock();
-    nret = sss_nss_make_request(SSS_NSS_GETGRNAM, &rd,
-                                &repbuf, &replen, &ret);
-    sss_nss_unlock();
-    free(repbuf);
-    if (nret != NSS_STATUS_SUCCESS && nret != NSS_STATUS_NOTFOUND) {
-        ERROR("NSS request failed (%1$d). Entry might remain in memory"
-               " cache.\n",nret);
+    /* Delete group from memory cache */
+    ret = sss_mc_refresh_group(pc_groupname);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
     }
 
     ret = EOK;
diff --git a/src/tools/sss_userdel.c b/src/tools/sss_userdel.c
index 53273f61dfb6f68773e77e8972cc7060da2a3c07..2cf77596b398c54b22a41c0d634f6fc6a315c35d 100644
--- a/src/tools/sss_userdel.c
+++ b/src/tools/sss_userdel.c
@@ -32,7 +32,6 @@
 #include "util/find_uid.h"
 #include "tools/tools_util.h"
 #include "tools/sss_sync_ops.h"
-#include "sss_client/sss_cli.h"
 
 #ifndef KILL_CMD
 #define KILL_CMD "killall"
@@ -121,10 +120,6 @@ int main(int argc, const char **argv)
     int ret = EXIT_SUCCESS;
     struct tools_ctx *tctx = NULL;
     const char *pc_username = NULL;
-    struct sss_cli_req_data rd;
-    uint8_t *repbuf = NULL;
-    size_t replen;
-    enum nss_status nret;
 
     int pc_debug = SSSDBG_DEFAULT;
     int pc_remove = 0;
@@ -292,18 +287,11 @@ int main(int argc, const char **argv)
     }
 
     /* Delete user from memory cache */
-    rd.data = pc_username;
-    rd.len = strlen(pc_username) + 1;
-
-    sss_nss_lock();
-    nret = sss_nss_make_request(SSS_NSS_GETPWNAM, &rd,
-                                &repbuf, &replen, &ret);
-
-    sss_nss_unlock();
-    free(repbuf);
-    if (nret != NSS_STATUS_SUCCESS && nret != NSS_STATUS_NOTFOUND) {
+    ret = sss_mc_refresh_user(pc_username);
+    if (ret != EOK) {
         ERROR("NSS request failed (%1$d). Entry might remain in memory "
-              "cache.\n",nret);
+              "cache.\n", ret);
+        /* Nothing we can do about it */
     }
 
     if (tctx->octx->remove_homedir) {
diff --git a/src/tools/tools_mc_util.c b/src/tools/tools_mc_util.c
index 5348829eb51389f920d415ab53b55ce6698843e6..9066d27a3b26b4c43804b6e9503dc51e0507ab08 100644
--- a/src/tools/tools_mc_util.c
+++ b/src/tools/tools_mc_util.c
@@ -25,6 +25,7 @@
 #include "util/util.h"
 #include "tools/tools_util.h"
 #include "util/mmap_cache.h"
+#include "sss_client/sss_cli.h"
 
 static errno_t sss_mc_set_recycled(int fd)
 {
@@ -185,3 +186,51 @@ errno_t sss_memcache_clear_all(void)
 
     return EOK;
 }
+
+enum sss_tools_ent {
+    SSS_TOOLS_USER,
+    SSS_TOOLS_GROUP
+};
+
+static errno_t sss_mc_refresh_ent(const char *name, enum sss_tools_ent ent)
+{
+    enum sss_cli_command cmd;
+    struct sss_cli_req_data rd;
+    uint8_t *repbuf = NULL;
+    size_t replen;
+    enum nss_status nret;
+    errno_t ret;
+
+    switch (ent) {
+        case SSS_TOOLS_USER:
+            cmd = SSS_NSS_GETPWNAM;
+            break;
+        case SSS_TOOLS_GROUP:
+            cmd = SSS_NSS_GETGRNAM;
+            break;
+    }
+
+    rd.data = name;
+    rd.len = strlen(name) + 1;
+
+    sss_nss_lock();
+    nret = sss_nss_make_request(cmd, &rd, &repbuf, &replen, &ret);
+    sss_nss_unlock();
+
+    free(repbuf);
+    if (nret != NSS_STATUS_SUCCESS && nret != NSS_STATUS_NOTFOUND) {
+        return EIO;
+    }
+
+    return EOK;
+}
+
+errno_t sss_mc_refresh_user(const char *username)
+{
+    return sss_mc_refresh_ent(username, SSS_TOOLS_USER);
+}
+
+errno_t sss_mc_refresh_group(const char *groupname)
+{
+    return sss_mc_refresh_ent(groupname, SSS_TOOLS_GROUP);
+}
diff --git a/src/tools/tools_util.h b/src/tools/tools_util.h
index aa55bfaf32386c3a3a2107219b26245b91ab97f8..0ca52efdf93e63245e0f83cfab84fd80f2bf3393 100644
--- a/src/tools/tools_util.h
+++ b/src/tools/tools_util.h
@@ -109,6 +109,9 @@ errno_t sss_memcache_invalidate(const char *mc_filename);
 
 errno_t sss_memcache_clear_all(void);
 
+errno_t sss_mc_refresh_user(const char *username);
+errno_t sss_mc_refresh_group(const char *groupname);
+
 /* from files.c */
 int remove_tree(const char *root);
 
-- 
1.8.0.2

-------------- next part --------------
>From de1c773381600a8b0bed4c5adcf9549fbf445ae3 Mon Sep 17 00:00:00 2001
From: Jakub Hrozek <jhrozek at redhat.com>
Date: Tue, 15 Jan 2013 12:35:58 +0100
Subject: [PATCH 3/4] TOOLS: Provide a convenience function to refresh a list
 of groups

---
 src/tools/tools_mc_util.c | 21 +++++++++++++++++++++
 src/tools/tools_util.h    |  1 +
 2 files changed, 22 insertions(+)

diff --git a/src/tools/tools_mc_util.c b/src/tools/tools_mc_util.c
index 9066d27a3b26b4c43804b6e9503dc51e0507ab08..ccbd49df62d7a35e53279977f88c74321a5dfc7a 100644
--- a/src/tools/tools_mc_util.c
+++ b/src/tools/tools_mc_util.c
@@ -234,3 +234,24 @@ errno_t sss_mc_refresh_group(const char *groupname)
 {
     return sss_mc_refresh_ent(groupname, SSS_TOOLS_GROUP);
 }
+
+errno_t sss_mc_refresh_grouplist(char **groupnames)
+{
+    int i;
+    errno_t ret;
+    bool failed = false;
+
+    if (!groupnames) return EOK;
+
+    for (i = 0; groupnames[i]; i++) {
+        ret = sss_mc_refresh_group(groupnames[i]);
+        if (ret != EOK) {
+            DEBUG(SSSDBG_MINOR_FAILURE,
+                  ("Cannot refresh group %s from memory cache\n"));
+            failed = true;
+            continue;
+        }
+    }
+
+    return failed ? EIO : EOK;
+}
diff --git a/src/tools/tools_util.h b/src/tools/tools_util.h
index 0ca52efdf93e63245e0f83cfab84fd80f2bf3393..3554a182d5d83380ec21c0b9b95972c35c17a04b 100644
--- a/src/tools/tools_util.h
+++ b/src/tools/tools_util.h
@@ -111,6 +111,7 @@ errno_t sss_memcache_clear_all(void);
 
 errno_t sss_mc_refresh_user(const char *username);
 errno_t sss_mc_refresh_group(const char *groupname);
+errno_t sss_mc_refresh_grouplist(char **groupnames);
 
 /* from files.c */
 int remove_tree(const char *root);
-- 
1.8.0.2

-------------- next part --------------
>From c34c507273555e1a0f0f939cbb132880d9f29c75 Mon Sep 17 00:00:00 2001
From: Jakub Hrozek <jhrozek at redhat.com>
Date: Tue, 15 Jan 2013 12:36:24 +0100
Subject: [PATCH 4/4] TOOLS: Refresh memcache after changes to local users and
 groups

---
 Makefile.am              | 10 ++++++++--
 src/tools/sss_groupmod.c | 21 +++++++++++++++++++++
 src/tools/sss_usermod.c  | 21 +++++++++++++++++++++
 3 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 710c10168d2665ce92b56fe792e88c6c1076911b..5cc009154e56ca0e563a81f3bfeffbf7dd3b0fc7 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -717,17 +717,23 @@ sss_groupdel_LDFLAGS = \
 
 sss_usermod_SOURCES = \
     src/tools/sss_usermod.c \
-    $(SSSD_TOOLS_OBJ)
+    $(SSSD_LCL_TOOLS_OBJ)
 sss_usermod_LDADD = \
     libsss_util.la \
     $(TOOLS_LIBS)
+sss_usermod_CFLAGS = $(AM_CFLAGS)
+sss_usermod_LDFLAGS = \
+    $(CLIENT_LIBS)
 
 sss_groupmod_SOURCES = \
     src/tools/sss_groupmod.c \
-    $(SSSD_TOOLS_OBJ)
+    $(SSSD_LCL_TOOLS_OBJ)
 sss_groupmod_LDADD = \
     libsss_util.la \
     $(TOOLS_LIBS)
+sss_groupmod_CFLAGS = $(AM_CFLAGS)
+sss_groupmod_LDFLAGS = \
+    $(CLIENT_LIBS)
 
 sss_groupshow_SOURCES = \
     src/tools/sss_groupshow.c \
diff --git a/src/tools/sss_groupmod.c b/src/tools/sss_groupmod.c
index 1d80c592133ffef9b3d4c674584f855854706aeb..8463857a12862df9597201b256a1389bd9846822 100644
--- a/src/tools/sss_groupmod.c
+++ b/src/tools/sss_groupmod.c
@@ -214,6 +214,27 @@ int main(int argc, const char **argv)
     }
     in_transaction = false;
 
+    ret = sss_mc_refresh_group(pc_groupname);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
+    ret = sss_mc_refresh_grouplist(tctx->octx->addgroups);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
+    ret = sss_mc_refresh_grouplist(tctx->octx->rmgroups);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
 done:
     if (in_transaction) {
         sret = sysdb_transaction_cancel(tctx->sysdb);
diff --git a/src/tools/sss_usermod.c b/src/tools/sss_usermod.c
index f6730368a81c469047af10b23b279a9771931bce..23630435c746ecd06d8f491f86c7a94ff5dfbaf6 100644
--- a/src/tools/sss_usermod.c
+++ b/src/tools/sss_usermod.c
@@ -236,6 +236,27 @@ int main(int argc, const char **argv)
     }
     in_transaction = false;
 
+    ret = sss_mc_refresh_user(pc_username);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
+    ret = sss_mc_refresh_grouplist(tctx->octx->addgroups);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
+    ret = sss_mc_refresh_grouplist(tctx->octx->rmgroups);
+    if (ret != EOK) {
+        ERROR("NSS request failed (%1$d). Entry might remain in memory "
+              "cache.\n", ret);
+        /* Nothing we can do about it */
+    }
+
     /* Set SELinux login context - must be done after transaction is done
      * b/c libselinux calls getpwnam */
     ret = set_seuser(tctx->octx->name, pc_selinux_user);
-- 
1.8.0.2



More information about the sssd-devel mailing list