Extend number_set interface

* number_set.h (number_set_array_is_empty, is_number_in_set_array,
add_number_to_set_array, clear_number_set_array,
invert_number_set_array, alloc_number_set_array, free_number_set_array):
New function prototypes.
* number_set.c (number_set_array_is_empty, is_number_in_set_array,
add_number_to_set_array, clear_number_set_array,
invert_number_set_array, alloc_number_set_array, free_number_set_array):
New functions.
* basic_filters.c (qualify_syscall_number, qualify_syscall_regex,
qualify_syscall_class, qualify_syscall_name): Use
add_number_to_set_array.
(qualify_syscall_tokens, qualify_tokens): Use
clear_number_set_array and invert_number_set_array.
* filter_qualify.c (qualify_inject_common): Use alloc_number_set_array,
number_set_array_is_empty, is_number_in_set_array,
add_number_to_set_array, and free_number_set_array.
(qual_flags): Use is_number_in_set_array.

diff --git a/basic_filters.c b/basic_filters.c
index be0c4c5120327b79e20e6313e069c4eb95d8d869..7b7f0a545753229cccc6ca78cec784177d00e6c1 100644 (file)
--- a/basic_filters.c
+++ b/basic_filters.c
@@ -45,7 +45,7 @@ qualify_syscall_number(const char *s, struct number_set *set)
                if ((unsigned) n >= nsyscall_vec[p]) {
                        continue;
                }
-               add_number_to_set(n, &set[p]);
+               add_number_to_set_array(n, set, p);
                done = true;
        }
 
@@ -85,7 +85,7 @@ qualify_syscall_regex(const char *s, struct number_set *set)
                                continue;
                        else if (rc)
                                regerror_msg_and_die(rc, &preg, "regexec", s);
-                       add_number_to_set(i, &set[p]);
+                       add_number_to_set_array(i, set, p);
                        found = true;
                }
        }
@@ -150,7 +150,7 @@ qualify_syscall_class(const char *s, struct number_set *set)
                            || (sysent_vec[p][i].sys_flags & n) != n) {
                                continue;
                        }
-                       add_number_to_set(i, &set[p]);
+                       add_number_to_set_array(i, set, p);
                }
        }
 
@@ -171,7 +171,7 @@ qualify_syscall_name(const char *s, struct number_set *set)
                            || strcmp(s, sysent_vec[p][i].sys_name)) {
                                continue;
                        }
-                       add_number_to_set(i, &set[p]);
+                       add_number_to_set_array(i, set, p);
                        found = true;
                }
        }
@@ -206,13 +206,7 @@ qualify_syscall_tokens(const char *const str, struct number_set *const set,
                       const char *const name)
 {
        /* Clear all sets. */
-       unsigned int p;
-       for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-               if (set[p].nslots)
-                       memset(set[p].vec, 0,
-                              sizeof(*set[p].vec) * set[p].nslots);
-               set[p].not = false;
-       }
+       clear_number_set_array(set, SUPPORTED_PERSONALITIES);
 
        /*
         * Each leading ! character means inversion
@@ -221,16 +215,14 @@ qualify_syscall_tokens(const char *const str, struct number_set *const set,
        const char *s = str;
 handle_inversion:
        while (*s == '!') {
-               for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-                       set[p].not = !set[p].not;
-               }
+               invert_number_set_array(set, SUPPORTED_PERSONALITIES);
                ++s;
        }
 
        if (strcmp(s, "none") == 0) {
                /*
                 * No syscall numbers are added to sets.
-                * Subsequent is_number_in_set invocations
+                * Subsequent is_number_in_set* invocations
                 * will return set[p]->not.
                 */
                return;
@@ -274,9 +266,7 @@ qualify_tokens(const char *const str, struct number_set *const set,
               string_to_uint_func func, const char *const name)
 {
        /* Clear the set. */
-       if (set->nslots)
-               memset(set->vec, 0, sizeof(*set->vec) * set->nslots);
-       set->not = false;
+       clear_number_set_array(set, 1);
 
        /*
         * Each leading ! character means inversion
@@ -285,14 +275,15 @@ qualify_tokens(const char *const str, struct number_set *const set,
        const char *s = str;
 handle_inversion:
        while (*s == '!') {
-               set->not = !set->not;
+               invert_number_set_array(set, 1);
                ++s;
        }
 
        if (strcmp(s, "none") == 0) {
                /*
                 * No numbers are added to the set.
-                * Subsequent is_number_in_set invocations will return set->not.
+                * Subsequent is_number_in_set* invocations
+                * will return set->not.
                 */
                return;
        } else if (strcmp(s, "all") == 0) {

diff --git a/filter_qualify.c b/filter_qualify.c
index 3ed0cb59174ccab606e7c0a4543bd1fc47d210df..bc10fcf2f78a05f4f96b2416e9498d6d186b4566 100644 (file)
--- a/filter_qualify.c
+++ b/filter_qualify.c
@@ -245,8 +245,8 @@ qualify_inject_common(const char *const str,
                }
        }
 
-       struct number_set tmp_set[SUPPORTED_PERSONALITIES];
-       memset(tmp_set, 0, sizeof(tmp_set));
+       struct number_set *tmp_set =
+               alloc_number_set_array(SUPPORTED_PERSONALITIES);
        qualify_syscall_tokens(name, tmp_set, description);
 
        free(buf);
@@ -257,9 +257,8 @@ qualify_inject_common(const char *const str,
         */
        unsigned int p;
        for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-               if (!tmp_set[p].nslots && !tmp_set[p].not) {
+               if (number_set_array_is_empty(tmp_set, p))
                        continue;
-               }
 
                if (!inject_vec[p]) {
                        inject_vec[p] = xcalloc(nsyscall_vec[p],
@@ -268,14 +267,14 @@ qualify_inject_common(const char *const str,
 
                unsigned int i;
                for (i = 0; i < nsyscall_vec[p]; ++i) {
-                       if (is_number_in_set(i, &tmp_set[p])) {
-                               add_number_to_set(i, &inject_set[p]);
+                       if (is_number_in_set_array(i, tmp_set, p)) {
+                               add_number_to_set_array(i, inject_set, p);
                                inject_vec[p][i] = opts;
                        }
                }
-
-               free(tmp_set[p].vec);
        }
+
+       free_number_set_array(tmp_set, SUPPORTED_PERSONALITIES);
 }
 
 static void
@@ -339,14 +338,14 @@ qualify(const char *str)
 unsigned int
 qual_flags(const unsigned int scno)
 {
-       return  (is_number_in_set(scno, &trace_set[current_personality])
+       return  (is_number_in_set_array(scno, trace_set, current_personality)
                   ? QUAL_TRACE : 0)
-               | (is_number_in_set(scno, &abbrev_set[current_personality])
+               | (is_number_in_set_array(scno, abbrev_set, current_personality)
                   ? QUAL_ABBREV : 0)
-               | (is_number_in_set(scno, &verbose_set[current_personality])
+               | (is_number_in_set_array(scno, verbose_set, current_personality)
                   ? QUAL_VERBOSE : 0)
-               | (is_number_in_set(scno, &raw_set[current_personality])
+               | (is_number_in_set_array(scno, raw_set, current_personality)
                   ? QUAL_RAW : 0)
-               | (is_number_in_set(scno, &inject_set[current_personality])
+               | (is_number_in_set_array(scno, inject_set, current_personality)
                   ? QUAL_INJECT : 0);
 }

diff --git a/number_set.c b/number_set.c
index e46efb0bd937f86ef8748051d7d6457573469797..e84ed20cf9b583ce2864eb28c25c794beec5e257 100644 (file)
--- a/number_set.c
+++ b/number_set.c
@@ -60,6 +60,13 @@ reallocate_number_set(struct number_set *const set, const unsigned int new_nslot
        set->nslots = new_nslots;
 }
 
+bool
+number_set_array_is_empty(const struct number_set *const set,
+                         const unsigned int idx)
+{
+       return !(set && (set[idx].nslots || set[idx].not));
+}
+
 bool
 is_number_in_set(const unsigned int number, const struct number_set *const set)
 {
@@ -67,9 +74,63 @@ is_number_in_set(const unsigned int number, const struct number_set *const set)
                && number_isset(number, set->vec)) ^ set->not;
 }
 
+bool
+is_number_in_set_array(const unsigned int number, const struct number_set *const set,
+                      const unsigned int idx)
+{
+       return set && ((number / BITS_PER_SLOT < set[idx].nslots)
+               && number_isset(number, set[idx].vec)) ^ set[idx].not;
+}
+
 void
 add_number_to_set(const unsigned int number, struct number_set *const set)
 {
        reallocate_number_set(set, number / BITS_PER_SLOT + 1);
        number_setbit(number, set->vec);
 }
+
+void
+add_number_to_set_array(const unsigned int number, struct number_set *const set,
+                       const unsigned int idx)
+{
+       add_number_to_set(number, &set[idx]);
+}
+
+void
+clear_number_set_array(struct number_set *const set, const unsigned int nmemb)
+{
+       unsigned int i;
+
+       for (i = 0; i < nmemb; ++i) {
+               if (set[i].nslots)
+                       memset(set[i].vec, 0,
+                              sizeof(*set[i].vec) * set[i].nslots);
+               set[i].not = false;
+       }
+}
+
+void
+invert_number_set_array(struct number_set *const set, const unsigned int nmemb)
+{
+       unsigned int i;
+
+       for (i = 0; i < nmemb; ++i)
+               set[i].not = !set[i].not;
+}
+
+struct number_set *
+alloc_number_set_array(const unsigned int nmemb)
+{
+       return xcalloc(nmemb, sizeof(struct number_set));
+}
+
+void
+free_number_set_array(struct number_set *const set, unsigned int nmemb)
+{
+       while (nmemb) {
+               --nmemb;
+               free(set[nmemb].vec);
+               set[nmemb].vec = NULL;
+       }
+       free(set);
+}

diff --git a/number_set.h b/number_set.h
index 0215d0b2c62ae75d2d6e7e5cd7bfe7231840f347..f0f34d4857d05d96a3f8dfeb32211bc52cba8954 100644 (file)
--- a/number_set.h
+++ b/number_set.h
@@ -36,12 +36,33 @@ struct number_set {
        bool not;
 };
 
+extern bool
+number_set_array_is_empty(const struct number_set *, unsigned int idx);
+
 extern bool
 is_number_in_set(unsigned int number, const struct number_set *);
 
+extern bool
+is_number_in_set_array(unsigned int number, const struct number_set *, unsigned int idx);
+
 extern void
 add_number_to_set(unsigned int number, struct number_set *);
 
+extern void
+add_number_to_set_array(unsigned int number, struct number_set *, unsigned int idx);
+
+extern void
+clear_number_set_array(struct number_set *, unsigned int nmemb);
+
+extern void
+invert_number_set_array(struct number_set *, unsigned int nmemb);
+
+extern struct number_set *
+alloc_number_set_array(unsigned int nmemb);
+
+extern void
+free_number_set_array(struct number_set *, unsigned int nmemb);
+
 extern struct number_set read_set;
 extern struct number_set write_set;
 extern struct number_set signal_set;