utils: use common code for apply_rules and apply_cipso

Code for apply_rules() has been rewritten to use opendir() and readdir(),
but apply_cipso() remained implemented with nftw().
This patch implements both applying functions with opendir() and readdir()
using a common internal function apply_path(). The common function can
handle both directory and single file,  so apply_rules_file() and
apply_cipso_file() are dropped.
The resulting code is 69 lines shorter and keeps directory traversal logic
in single place. It's side effect is applying CIPSO rules in one shot, just
like regular Smack rules.

Signed-off-by: Rafal Krypa <r.krypa@samsung.com>

diff --git a/utils/common.c b/utils/common.c
index 1b6efdd..55fee1a 100644 (file)
--- a/utils/common.c
+++ b/utils/common.c
@@ -22,19 +22,15 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <ftw.h>
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
 #include <sys/smack.h>
 
-#define SMACK_MAGIC 0x43415d53
-
-static int apply_cipso_cb(const char *fpath, const struct stat *sb,
-                         int typeflag, struct FTW *ftwbuf);
+typedef int (*add_func)(void *smack, int fd);
 
 int clear(void)
 {
-       int fd;
        int ret;
        const char * smack_mnt;
        char path[PATH_MAX];
@@ -44,30 +40,23 @@ int clear(void)
                return -1;
 
        snprintf(path, sizeof path, "%s/load2", smack_mnt);
-       fd = open(path, O_RDONLY);
-       if (fd < 0) {
-               fprintf(stderr, "open() failed for '%s' : %s\n", path,
-                       strerror(errno));
-               return -1;
-       }
-
-       ret = apply_rules_file(path, fd, 1);
-       close(fd);
+       ret = apply_rules(path, 1);
        return ret;
 }
 
-int apply_rules(const char *path, int clear)
+static int apply_path(const char *path, void *smack, add_func func)
 {
-       struct smack_accesses *rules = NULL;
        DIR *dir;
        struct dirent *dent;
        int dfd;
        int fd;
        int ret = 0;
 
-       if (smack_accesses_new(&rules)) {
-               fprintf(stderr, "Out of memory.\n");
-               return -1;
+       if (path == NULL) {
+               ret = func(smack, STDIN_FILENO);
+               if (ret < 0)
+                       fputs("Reading from STDIN failed.\n", stderr);
+               return ret;
        }
 
        dir = opendir(path);
@@ -99,26 +88,15 @@ int apply_rules(const char *path, int clear)
                                break;
                        }
 
-                       ret = smack_accesses_add_from_file(rules, fd);
+                       ret = func(smack, fd);
                        close(fd);
                        if (ret < 0) {
-                               fprintf(stderr, "Reading rules from '%s' failed.\n",
+                               fprintf(stderr, "Reading from '%s' failed.\n",
                                        path);
                                break;
                        }
                }
 
-               if (clear) {
-                       ret = smack_accesses_clear(rules);
-                       if (ret)
-                               fputs("Clearing rules failed.\n", stderr);
-               } else {
-                       ret = smack_accesses_apply(rules);
-                       if (ret)
-                               fputs("Applying rules failed.\n", stderr);
-               }
-
-               smack_accesses_free(rules);
                closedir(dir);
                return ret;
        }
@@ -136,54 +114,27 @@ int apply_rules(const char *path, int clear)
                return -1;
        }
 
-       ret = apply_rules_file(path, fd, clear);
+       ret = func(smack, fd);
+       if (ret < 0)
+               fprintf(stderr, "Reading from '%s' failed.\n", path);
        close(fd);
        return ret;
 }
 
-int apply_cipso(const char *path)
+int apply_rules(const char *path, int clear)
 {
-       struct stat sbuf;
-       int fd;
+       struct smack_accesses *rules = NULL;
        int ret;
 
-       if (stat(path, &sbuf)) {
-               fprintf(stderr, "stat() failed for '%s' : %s\n", path,
-                       strerror(errno));
-               return -1;
-       }
-
-       if (S_ISDIR(sbuf.st_mode))
-               return nftw(path, apply_cipso_cb, 1, FTW_PHYS|FTW_ACTIONRETVAL);
-
-       fd = open(path, O_RDONLY);
-       if (fd < 0) {
-               fprintf(stderr, "open() failed for '%s' : %s\n", path,
-                       strerror(errno));
+       if (smack_accesses_new(&rules)) {
+               fputs("Out of memory.\n", stderr);
                return -1;
        }
 
-       ret = apply_cipso_file(path, fd);
-       close(fd);
-       return ret;
-}
-
-int apply_rules_file(const char *path, int fd, int clear)
-{
-       struct smack_accesses *rules = NULL;
-       int ret = 0;
-
-       if (smack_accesses_new(&rules))
-               return -1;
-
-       if (smack_accesses_add_from_file(rules, fd)) {
+       ret = apply_path(path, rules, (add_func) smack_accesses_add_from_file);
+       if (ret) {
                smack_accesses_free(rules);
-               if (path)
-                       fprintf(stderr, "Reading rules from '%s' failed.\n",
-                               path);
-               else
-                       fputs("Reading rules from STDIN failed.\n", stderr);
-               return -1;
+               return ret;
        }
 
        if (clear) {
@@ -197,28 +148,24 @@ int apply_rules_file(const char *path, int fd, int clear)
        }
 
        smack_accesses_free(rules);
-       return ret;
+       return 0;
 }
 
-int apply_cipso_file(const char *path, int fd)
+int apply_cipso(const char *path)
 {
        struct smack_cipso *cipso = NULL;
        int ret;
 
        ret = smack_cipso_new(&cipso);
-       if (ret)
+       if (ret) {
+               fputs("Out of memory.\n", stderr);
                return -1;
+       }
 
-       ret = smack_cipso_add_from_file(cipso, fd);
+       ret = apply_path(path, cipso, (add_func) smack_cipso_add_from_file);
        if (ret) {
-               if (path)
-                       fprintf(stderr, "Reading CIPSO from '%s' failed.\n",
-                               path);
-               else
-                       fputs("Reading CIPSO from STDIN failed.\n",
-                             stderr);
                smack_cipso_free(cipso);
-               return -1;
+               return ret;
        }
 
        ret = smack_cipso_apply(cipso);
@@ -230,26 +177,3 @@ int apply_cipso_file(const char *path, int fd)
 
        return 0;
 }
-
-static int apply_cipso_cb(const char *fpath, const struct stat *sb,
-                         int typeflag, struct FTW *ftwbuf)
-{
-       int fd;
-       int ret;
-
-       if (typeflag == FTW_D)
-               return ftwbuf->level ? FTW_SKIP_SUBTREE : FTW_CONTINUE;
-       else if (typeflag != FTW_F)
-               return FTW_STOP;
-
-       fd = open(fpath, O_RDONLY);
-       if (fd < 0) {
-               fprintf(stderr, "open() failed for '%s' : %s\n", fpath,
-                       strerror(errno));
-               return -1;
-       }
-
-       ret = apply_cipso_file(fpath, fd) ? FTW_STOP : FTW_CONTINUE;
-       close(fd);
-       return ret;
-}

diff --git a/utils/common.h b/utils/common.h
index 1eab142..e74ecdc 100644 (file)
--- a/utils/common.h
+++ b/utils/common.h
@@ -27,7 +27,5 @@
 int clear(void);
 int apply_rules(const char *path, int clear);
 int apply_cipso(const char *path);
-int apply_rules_file(const char *path, int fd, int clear);
-int apply_cipso_file(const char *path, int fd);
 
 #endif // COMMON_H

diff --git a/utils/smackcipso.c b/utils/smackcipso.c
index 643f080..e87885a 100644 (file)
--- a/utils/smackcipso.c
+++ b/utils/smackcipso.c
@@ -21,7 +21,6 @@
 #include "common.h"
 #include <stdlib.h>
 #include <stdio.h>
-#include <unistd.h>
 
 int main(int argc, char **argv)
 {
@@ -36,7 +35,7 @@ int main(int argc, char **argv)
        }
 
        if (argc == 1) {
-               if (apply_cipso_file(NULL, STDIN_FILENO))
+               if (apply_cipso(NULL))
                        exit(1);
        } else {
                if (apply_cipso(argv[1]))

diff --git a/utils/smackload.c b/utils/smackload.c
index 04aca44..5c7cc9c 100644 (file)
--- a/utils/smackload.c
+++ b/utils/smackload.c
@@ -50,7 +50,7 @@ int main(int argc, char **argv)
        }
 
        if (optind == argc) {
-               if (apply_rules_file(NULL, STDIN_FILENO, clear))
+               if (apply_rules(NULL, clear))
                        exit(1);
        } else {
                if (apply_rules(argv[optind], clear))