From b83312dd8495286516f0c972735b8502a7e5893b Mon Sep 17 00:00:00 2001 From: Jarkko Sakkinen Date: Wed, 17 Nov 2010 19:51:08 -0800 Subject: [PATCH] Simplified smack_read_rules_from_file(). --- src/smack.h | 11 ++++----- src/smack_rules.c | 65 +++++++++++++++++++++++++---------------------------- tests/check_rules.c | 54 +++++++++++++++----------------------------- 3 files changed, 52 insertions(+), 78 deletions(-) diff --git a/src/smack.h b/src/smack.h index 75b75bb..d0de089 100644 --- a/src/smack.h +++ b/src/smack.h @@ -63,17 +63,14 @@ extern void smack_destroy_rules(smack_rules_t handle); /*! * Read rules from a given file. Rules can be optionally filtered by a - * subject. Old rules are replaced with read ruleset on success full - * read. + * subject. * - * @param handle handle to a rules * @param path path to the file containing rules * @param subject read only rules for the given subject if not set to NULL. - * @return 0 on success + * @return smack_rules_t instance on success */ -extern int smack_read_rules_from_file(smack_rules_t handle, - const char *path, - const char *subject); +extern smack_rules_t smack_read_rules_from_file(const char *path, + const char *subject); /*! * Write rules to a given file. diff --git a/src/smack_rules.c b/src/smack_rules.c index 473b11c..3595ed1 100644 --- a/src/smack_rules.c +++ b/src/smack_rules.c @@ -56,7 +56,6 @@ struct smack_rules { static int update_rule(struct smack_subject **subjects, const char *subject_str, const char *object_str, unsigned ac); -static void destroy_rules(struct smack_subject **subjects); inline unsigned str_to_ac(const char *str); inline void ac_to_config_str(unsigned ac, char *str); inline void ac_to_kernel_str(unsigned ac, char *str); @@ -70,24 +69,44 @@ smack_rules_t smack_create_rules(void) void smack_destroy_rules(smack_rules_t handle) { - destroy_rules(&handle->subjects); + struct smack_subject *s; + struct smack_object *o; + + while (handle->subjects != NULL) { + s = handle->subjects; + while (s->objects != NULL) { + o = s->objects; + HASH_DEL(s->objects, o); + free(o->object); + free(o); + } + HASH_DEL(handle->subjects, s); + free(s->subject); + free(s); + } + free(handle); } -int smack_read_rules_from_file(smack_rules_t handle, const char *path, - const char *subject_filter) +smack_rules_t smack_read_rules_from_file(const char *path, + const char *subject_filter) { FILE *file; char *buf = NULL; const char *subject, *object, *access; unsigned ac; size_t size; - struct smack_subject *subjects = NULL; int ret = 0; file = fopen(path, "r"); if (file == NULL) - return -1; + return NULL; + + smack_rules_t rules = smack_create_rules(); + if (rules == NULL) { + fclose(file); + return NULL; + } while (ret == 0 && getline(&buf, &size, file) != -1) { subject = strtok(buf, " \n"); @@ -100,26 +119,21 @@ int smack_read_rules_from_file(smack_rules_t handle, const char *path, } else if (subject_filter == NULL || strcmp(subject, subject_filter) == 0) { ac = str_to_ac(access); - ret = update_rule(&subjects, subject, object, ac); + ret = update_rule(&rules->subjects, subject, object, ac); } free(buf); buf = NULL; } - if (ferror(file)) - ret = -1; - - if (ret == 0) { - destroy_rules(&handle->subjects); - handle->subjects = subjects; - } else { - destroy_rules(&subjects); + if (ret != 0 || ferror(file)) { + smack_destroy_rules(rules); + rules = NULL; } free(buf); fclose(file); - return ret; + return rules; } int smack_write_rules_to_file(smack_rules_t handle, const char *path) @@ -288,25 +302,6 @@ static int update_rule(struct smack_subject **subjects, return 0; } -static void destroy_rules(struct smack_subject **subjects) -{ - struct smack_subject *s; - struct smack_object *o; - - while (*subjects != NULL) { - s = *subjects; - while (s->objects != NULL) { - o = s->objects; - HASH_DEL(s->objects, o); - free(o->object); - free(o); - } - HASH_DEL(*subjects, s); - free(s->subject); - free(s); - } -} - inline unsigned str_to_ac(const char *str) { int i, count; diff --git a/tests/check_rules.c b/tests/check_rules.c index 494ad7f..40823e4 100644 --- a/tests/check_rules.c +++ b/tests/check_rules.c @@ -30,10 +30,8 @@ static int files_equal(const char *filename1, const char *filename2); START_TEST(test_add_new_rule) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/add_new_rule-in.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/add_new_rule-in.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_add_rule(rules, "Orange", "Apple", "ra"); fail_unless(rc == 0, "Failed to add rule"); rc = smack_write_rules_to_kernel(rules, "add_new_rule-result.txt"); @@ -47,10 +45,8 @@ END_TEST START_TEST(test_modify_existing_rule) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/modify_existing_rule-in.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/modify_existing_rule-in.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_add_rule(rules, "Foo", "Bar", "wx"); fail_unless(rc == 0, "Failed to add rule"); rc = smack_write_rules_to_kernel(rules, "modify_existing_rule-result.txt"); @@ -64,10 +60,8 @@ END_TEST START_TEST(test_rw_rules_config) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/write_rules_config-excepted.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/write_rules_config-excepted.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_write_rules_to_file(rules, "write_rules_config-result.txt"); fail_unless(rc == 0, "Failed to write ruleset"); rc = files_equal("write_rules_config-result.txt", "data/write_rules_config-excepted.txt"); @@ -79,10 +73,8 @@ END_TEST START_TEST(test_rw_rules_kernel) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/write_rules_config-excepted.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/write_rules_config-excepted.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_write_rules_to_kernel(rules, "write_rules_kernel-result.txt"); fail_unless(rc == 0, "Failed to write ruleset"); rc = files_equal("write_rules_kernel-result.txt", "data/write_rules_kernel-excepted.txt"); @@ -94,10 +86,8 @@ END_TEST START_TEST(test_remove_rule) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/remove_rule-in.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/remove_rule-in.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_remove_rule(rules, "Orange", "Apple"); fail_unless(rc == 0, "Failed to remove rule"); rc = smack_write_rules_to_kernel(rules, "remove_rule-result.txt"); @@ -111,10 +101,8 @@ END_TEST START_TEST(test_remove_rules_by_subject) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/remove_rules_by_subject-in.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/remove_rules_by_subject-in.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); smack_remove_rules_by_subject(rules, "Foo"); rc = smack_write_rules_to_kernel(rules, "remove_rules_by_subject-result.txt"); fail_unless(rc == 0, "Failed to write ruleset"); @@ -127,10 +115,8 @@ END_TEST START_TEST(test_remove_rules_by_object) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/remove_rules_by_object-in.txt", NULL); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/remove_rules_by_object-in.txt", NULL); + fail_unless(rules != NULL, "Reading rules failed"); smack_remove_rules_by_object(rules, "Apple"); rc = smack_write_rules_to_kernel(rules, "remove_rules_by_object-result.txt"); fail_unless(rc == 0, "Failed to write ruleset"); @@ -143,10 +129,8 @@ END_TEST START_TEST(test_have_access_rule) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Ruleset creation failed"); - rc = smack_read_rules_from_file(rules, "data/have_access_rule-in.txt", "Orange"); - fail_unless(rc == 0, "Failed to read ruleset"); + smack_rules_t rules = smack_read_rules_from_file("data/have_access_rule-in.txt", "Orange"); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_have_access_rule(rules, "Orange", "Apple", "a"); fail_unless(rc, "Have access \"a\" failed"); smack_destroy_rules(rules); @@ -156,10 +140,8 @@ END_TEST START_TEST(test_have_access_removed_rule) { int rc; - smack_rules_t rules = smack_create_rules(); - fail_unless(rules != NULL, "Rules creation failed"); - rc = smack_read_rules_from_file(rules, "data/have_access_rule-in.txt", "Orange"); - fail_unless(rc == 0, "Failed to read rules"); + smack_rules_t rules = smack_read_rules_from_file("data/have_access_rule-in.txt", "Orange"); + fail_unless(rules != NULL, "Reading rules failed"); rc = smack_remove_rule(rules, "Orange", "Apple"); fail_unless(rc == 0, "Failed to remove rule"); rc = smack_have_access_rule(rules, "Orange", "Apple", "a"); -- 2.7.4