[PATCH v7 5/8] Implement new filtering language parsing
Nikolay Marchuk
marchuk.nikolay.a at gmail.com
Fri Aug 11 10:43:50 UTC 2017
* basic_filters.c (parse_set, parse_syscall_set): Use set inversion only in
qualify mode.
* filter.h (parse_filter_action, parse_qualify_action,
parse_filter_expression): Add new declarations.
* filter_action.c (parse_filter_action): Add new parsing function.
(filtering_parse_finish): Use filtering_parse instead of
parse_qualify_filter.
* filter_expression.c (parse_filter_expression): Implement parsing of filter
expression.
(add_variable_token, add_operator_token, parse_operator, push_operator,
is_higher_priority, is_allowed_in_name): Add helper functions.
(is_space_ascii): Add new definition.
* filter_parse.c: New file.
* filter_qualify.c (parse_read, parse_write, qualify_signals, parse_trace,
parse_abbrev, parse_verbose, parse_raw, parse_inject_common, parse_fault,
parse_inject): Use new parsing API.
* strace.c (init): Use filtering_parse instead of parse_qualify_filter.
* Makefile.am (strace_SOURCES): Add filter_parse.c.
* defs.h (filtering_parse): Add new definition.
---
Makefile.am | 1 +
basic_filters.c | 34 +++---
defs.h | 2 +-
filter.h | 7 ++
filter_action.c | 14 ++-
filter_expression.c | 220 +++++++++++++++++++++++++++++++++++
filter_parse.c | 223 ++++++++++++++++++++++++++++++++++++
filter_qualify.c | 99 +++++++++-------
strace.c | 6 +-
tests/filtering_syscall-syntax.test | 17 +--
10 files changed, 546 insertions(+), 77 deletions(-)
create mode 100644 filter_parse.c
diff --git a/Makefile.am b/Makefile.am
index 84df39a8..ae10dc5f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -136,6 +136,7 @@ strace_SOURCES = \
file_ioctl.c \
filter_action.c \
filter_expression.c \
+ filter_parse.c \
filter_qualify.c \
filter.c \
filter.h \
diff --git a/basic_filters.c b/basic_filters.c
index ada7b1a5..f12c9046 100644
--- a/basic_filters.c
+++ b/basic_filters.c
@@ -254,15 +254,17 @@ parse_syscall_set(const char *const str, struct number_set *const set)
unsigned int p;
const char *s = str;
- /*
- * Each leading ! character means inversion
- * of the remaining specification.
- */
- while (*s == '!') {
- for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
- set[p].not = !set[p].not;
+ if (parsing_qualify_mode) {
+ /*
+ * Each leading ! character means inversion
+ * of the remaining specification.
+ */
+ while (*s == '!') {
+ for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+ set[p].not = !set[p].not;
+ }
+ ++s;
}
- ++s;
}
if (strcmp(s, "none") == 0) {
@@ -345,13 +347,15 @@ parse_set(const char *const str, struct number_set *const set,
{
const char *s = str;
- /*
- * Each leading ! character means inversion
- * of the remaining specification.
- */
- while (*s == '!') {
- set->not = !set->not;
- ++s;
+ if (parsing_qualify_mode) {
+ /*
+ * Each leading ! character means inversion
+ * of the remaining specification.
+ */
+ while (*s == '!') {
+ set->not = !set->not;
+ ++s;
+ }
}
if (strcmp(s, "none") == 0) {
diff --git a/defs.h b/defs.h
index 69cd765e..13893f64 100644
--- a/defs.h
+++ b/defs.h
@@ -670,7 +670,7 @@ extern struct number_set signal_set;
extern bool is_number_in_set(unsigned int number, const struct number_set *);
extern void filtering_parsing_finish(void);
extern void filter_syscall(struct tcb *);
-extern void parse_qualify_filter(const char *);
+extern void filtering_parse(const char *);
#define DECL_IOCTL(name) \
extern int \
diff --git a/filter.h b/filter.h
index 7509b1e5..3861f8b8 100644
--- a/filter.h
+++ b/filter.h
@@ -35,6 +35,8 @@ struct filter_action;
struct bool_expression;
+extern bool parsing_qualify_mode;
+
typedef int (*string_to_uint_func)(const char *);
void parse_set(const char *const, struct number_set *const,
string_to_uint_func, const char *const);
@@ -56,6 +58,7 @@ void set_filters_qualify_mode(struct filter **, unsigned int *nfilters);
/* filter action api */
struct filter *create_filter(struct filter_action *, const char *name);
struct filter_action *find_or_add_action(const char *);
+void parse_filter_action(const char *, const char *, const char *);
void *get_filter_action_priv_data(struct filter_action *);
void set_filter_action_priv_data(struct filter_action *, void *);
void set_qualify_mode(struct filter_action *);
@@ -64,5 +67,9 @@ void set_qualify_mode(struct filter_action *);
struct bool_expression *create_expression();
bool run_expression(struct bool_expression *, bool *, unsigned int);
void set_expression_qualify_mode(struct bool_expression *);
+void parse_filter_expression(struct bool_expression *, const char *,
+ struct filter_action *, unsigned int);
+
+void parse_qualify_action(const char *, const char *, const char *);
#endif /* !STRACE_FILTER_H */
diff --git a/filter_action.c b/filter_action.c
index be4af4d3..776ffded 100644
--- a/filter_action.c
+++ b/filter_action.c
@@ -127,7 +127,7 @@ filtering_parsing_finish(void)
/* Init trace action if pathtracing is enabled */
if (tracing_paths && (default_flags & QUAL_TRACE))
- parse_qualify_filter("trace=all");
+ filtering_parse("trace=all");
/* Sort actions by priority */
if (nfilter_actions == 0)
@@ -193,6 +193,18 @@ find_or_add_action(const char *name)
return add_action(type);
}
+void
+parse_filter_action(const char *action_name, const char *expr, const char *args)
+{
+ struct filter_action *action = find_or_add_action(action_name);
+
+ parse_filter_expression(action->expr, expr, action, action->nfilters);
+ if (args && action->type->parse_args == &parse_null)
+ error_msg("%s action takes no arguments, ignored argument '%s'",
+ action->type->name, args);
+ action->_priv_data = action->type->parse_args(args);
+}
+
static void
run_filter_action(struct tcb *tcp, struct filter_action *action)
{
diff --git a/filter_expression.c b/filter_expression.c
index 05f8903e..c991bb2b 100644
--- a/filter_expression.c
+++ b/filter_expression.c
@@ -27,6 +27,16 @@
#include "defs.h"
#include <stdarg.h>
+#include "filter.h"
+
+extern bool is_space_ascii(char);
+
+static bool
+is_allowed_in_name(char c)
+{
+ return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
+ || (c >= '0' && c <= '9') || (c == '_');
+}
struct expression_token {
enum token_type {
@@ -42,6 +52,8 @@ struct expression_token {
} operator_id;
} data;
};
+/* Pseudo-operator for parsing */
+#define OP_PARENTHESIS 3
struct bool_expression {
unsigned int ntokens;
@@ -68,6 +80,25 @@ reallocate_expression(struct bool_expression *const expr,
expr->ntokens = new_ntokens;
}
+static void
+add_variable_token(struct bool_expression *expr, unsigned int id)
+{
+ struct expression_token token;
+ token.type = TOK_VARIABLE;
+ token.data.variable_id = id;
+ reallocate_expression(expr, expr->ntokens + 1);
+ expr->tokens[expr->ntokens - 1] = token;
+}
+
+static void
+add_operator_token(struct bool_expression *expr, int op) {
+ struct expression_token token;
+ token.type = TOK_OPERATOR;
+ token.data.operator_id = op;
+ reallocate_expression(expr, expr->ntokens + 1);
+ expr->tokens[expr->ntokens - 1] = token;
+}
+
void
set_expression_qualify_mode(struct bool_expression *expr)
{
@@ -233,3 +264,192 @@ run_expression(struct bool_expression *expr, bool *variables,
variables, variables_num);
return stack[0];
}
+
+/*
+ * Parse operator and add operator length to str and pos.
+ * Return -1 if no operator found.
+ */
+static int
+parse_operator(char **str, unsigned int *pos)
+{
+#define _OP(s, op) { s, sizeof(s) - 1, op }
+ struct {
+ const char *str;
+ int len;
+ enum operator_type op;
+ } ops[] = {
+ _OP("!", OP_NOT),
+ _OP("not", OP_NOT),
+ _OP("&&", OP_AND),
+ _OP("and", OP_AND),
+ _OP("||", OP_OR),
+ _OP("or", OP_OR),
+ };
+#undef _OP
+ char *p = *str;
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(ops); i++) {
+ if (!strncmp(p, ops[i].str, ops[i].len) &&
+ (!is_allowed_in_name(ops[i].str[0]) ||
+ !is_allowed_in_name(p[ops[i].len]))) {
+ *str += ops[i].len - 1;
+ *pos += ops[i].len - 1;
+ return ops[i].op;
+ }
+ }
+ return -1;
+}
+
+static char *
+unescape_argument(char **str)
+{
+ char *p;
+ char *p_new;
+ bool escaped = false;
+ unsigned int size = 1;
+ char *new_str = xcalloc(strlen(*str) + 1, 1);
+
+ for (p = *str, p_new = new_str; *p; ++p) {
+ if (!escaped) {
+ if (*p == '\\') {
+ escaped = true;
+ continue;
+ } else if (is_space_ascii(*p) || *p == ')' || *p == '|'
+ || *p == '&') {
+ break;
+ }
+ }
+ escaped = false;
+ *(p_new++) = *p;
+ size++;
+ }
+ *str = p - 1;
+ return xreallocarray(new_str, size, 1);;
+}
+
+static void
+push_operator(int *stack, unsigned int *stack_size, int op)
+{
+ if (*stack_size == MAX_STACK_SIZE)
+ error_msg_and_die("stack overflow");
+ stack[*stack_size] = op;
+ (*stack_size)++;
+}
+
+static bool
+is_higher_priority(int op_a, int op_b)
+{
+ bool op_priority[] = {
+ [OP_NOT] = 2,
+ [OP_AND] = 1,
+ [OP_OR] = 0
+ };
+ return op_priority[op_a] > op_priority[op_b];
+}
+
+void
+parse_filter_expression(struct bool_expression *expr, const char *str,
+ struct filter_action *action, unsigned int start_id)
+{
+ enum {
+ WAIT_FILTER,
+ FILTER_NAME,
+ FILTER_ARG,
+ WAIT_OPERATOR,
+ } state = WAIT_FILTER;
+ unsigned int variable_id = start_id;
+ /* Current stack stack_size */
+ unsigned int st_size = 0;
+ int stack[MAX_STACK_SIZE];
+ char *buf = xstrdup(str);
+ struct filter *cur_filter = NULL;
+ char *filter_name = NULL;
+ char *filter_arg = NULL;
+ int op;
+ char *p;
+ unsigned int pos = 0;
+
+ for (p = buf; *p; ++p, ++pos) {
+ switch (state) {
+ case WAIT_FILTER:
+ if (*p == '(') {
+ push_operator(stack, &st_size, OP_PARENTHESIS);
+ } else if ((op = parse_operator(&p, &pos)) >= 0) {
+ if (op == OP_NOT) {
+ push_operator(stack, &st_size, op);
+ } else {
+ error_msg_and_die("invalid operator "
+ "at '%s':%u",
+ str, pos);
+ }
+ } else if (!is_space_ascii(*p)) {
+ filter_name = p;
+ state = FILTER_NAME;
+ }
+ break;
+
+ case FILTER_NAME:
+ if (is_space_ascii(*p)) {
+ *p = '\0';
+ cur_filter = create_filter(action, filter_name);
+ filter_arg = NULL;
+ state = FILTER_ARG;
+ }
+ break;
+
+ case FILTER_ARG:
+ if (!filter_arg && is_space_ascii(*p))
+ break;
+ filter_arg = unescape_argument(&p);
+ parse_filter(cur_filter, filter_arg);
+ free(filter_arg);
+ add_variable_token(expr, variable_id++);
+ state = WAIT_OPERATOR;
+ break;
+
+ case WAIT_OPERATOR:
+ if (is_space_ascii(*p))
+ break;
+ if (*p == ')') {
+ while ((st_size > 0) &&
+ (stack[st_size - 1] != OP_PARENTHESIS)) {
+ op = stack[--st_size];
+ add_operator_token(expr, op);
+ }
+ if (st_size == 0)
+ error_msg_and_die("unexpected ')' at "
+ "'%s':%u", str, pos);
+ --st_size;
+ break;
+ }
+ op = parse_operator(&p, &pos);
+ if (op < 0 || op == OP_NOT)
+ error_msg_and_die("invalid operator at '%s':%u",
+ str, pos);
+
+ /* Pop operators with higher priority. */
+ while ((st_size > 0) &&
+ (stack[st_size - 1] != OP_PARENTHESIS) &&
+ is_higher_priority(stack[st_size - 1], op))
+ add_operator_token(expr, stack[--st_size]);
+
+ push_operator(stack, &st_size, op);
+ state = WAIT_FILTER;
+ break;
+ }
+ }
+
+ free(buf);
+ if (state != WAIT_OPERATOR)
+ error_msg_and_die("unfinished filter expression '%s'", str);
+
+ while (st_size > 0) {
+ if (stack[--st_size] == OP_PARENTHESIS)
+ error_msg_and_die("missing ')' in expression '%s'",
+ str);
+ add_operator_token(expr, stack[st_size]);
+ }
+ if (start_id > 0)
+ add_operator_token(expr, OP_OR);
+}
diff --git a/filter_parse.c b/filter_parse.c
new file mode 100644
index 00000000..27d677ae
--- /dev/null
+++ b/filter_parse.c
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikolay.a at gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include "filter.h"
+
+bool
+is_space_ascii(char c)
+{
+ return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') ||
+ (c == '\v') || (c == '\f');
+}
+
+/*
+ * Split expression into action name, filter expression or qualify set
+ * and action arguments.
+ */
+void
+filtering_parse(const char *str)
+{
+ enum parsing_states {
+ F_EMPTY,
+ F_BEGIN,
+ F_QUAL_SET,
+ F_FILT_EXPR,
+ F_QUAL_ARGS,
+ F_FILT_ARGS,
+ F_END,
+ } state = F_EMPTY;
+ const char *begin = NULL;
+ const char *action_name = NULL;
+ const char *main_part = NULL;
+ const char *args = NULL;
+ bool escaped = false;
+ int parentheses_count = 0;
+ /* Used to store position of last terminating parenthesis. */
+ char *expression_end = NULL;
+ /* Used to provide diagnostics. */
+ unsigned int pos = 0;
+ char *buf = xstrdup(str);
+ char *p;
+
+ for (p = buf; *p; ++p, ++pos) {
+ switch (state) {
+ case F_EMPTY:
+ switch (*p) {
+ /* trace(), action name omitted */
+ case '(':
+ parentheses_count++;
+ action_name = "trace";
+ main_part = buf;
+ state = F_FILT_EXPR;
+ break;
+ case '=':
+ error_msg_and_die("invalid filter action ''");
+ default:
+ if (!is_space_ascii(*p)) {
+ begin = p;
+ state = F_BEGIN;
+ }
+ }
+ if (state != F_BEGIN)
+ break;
+ /* else fall through to check for qualify set */
+
+ case F_BEGIN:
+ switch (*p) {
+ /* action(...) */
+ case '(':
+ parentheses_count++;
+ /* expression without action with leading ! */
+ if (*begin == '!')
+ break;
+ action_name = begin;
+ *p = '\0';
+ main_part = p + 1;
+ state = F_FILT_EXPR;
+ break;
+ /* action=... */
+ case '=':
+ action_name = begin;
+ *p = '\0';
+ main_part = p + 1;
+ state = F_QUAL_SET;
+ break;
+ /* qualify set without action. */
+ case ',':
+ case '?':
+ case '/':
+ case '%':
+ case '-':
+ action_name = "trace";
+ main_part = begin;
+ state = F_QUAL_SET;
+ break;
+ default:
+ /* new expression without action. */
+ if (is_space_ascii(*p)) {
+ action_name = "trace";
+ main_part = begin;
+ state = F_FILT_EXPR;
+ }
+ }
+ break;
+
+ case F_QUAL_SET:
+ if (*p == ':') {
+ *p = '\0';
+ args = p + 1;
+ state = F_QUAL_ARGS;
+ }
+ break;
+
+ case F_FILT_EXPR:
+ if (!escaped) {
+ switch (*p) {
+ case ';':
+ if (parentheses_count != 1)
+ error_msg_and_die("invalid "
+ "arguments "
+ "position "
+ "'%s':%u",
+ str, pos);
+ *p = '\0';
+ args = p + 1;
+ state = F_FILT_ARGS;
+ break;
+ case '(':
+ parentheses_count++;
+ break;
+ case ')':
+ if (parentheses_count <= 0)
+ error_msg_and_die("unexpected "
+ "')' at "
+ "'%s':%u",
+ str, pos);
+ parentheses_count--;
+ expression_end = p;
+ break;
+ case '\\':
+ escaped = true;
+ break;
+ }
+ } else
+ escaped = false;
+ break;
+
+ case F_QUAL_ARGS:
+ break;
+ case F_FILT_ARGS:
+ if (!escaped) {
+ switch (*p) {
+ case ')':
+ if (parentheses_count <= 0)
+ error_msg_and_die("unexpected "
+ "')' at "
+ "'%s':%u",
+ str, pos);
+ parentheses_count--;
+ expression_end = p;
+ state = F_END;
+ break;
+ case '\\':
+ escaped = true;
+ break;
+ }
+ } else
+ escaped = false;
+ break;
+ case F_END:
+ if (!is_space_ascii(*p))
+ error_msg_and_die("illegal character '%c' in "
+ "'%s':%u", *p, str, pos);
+ }
+ }
+
+ switch (state) {
+ case F_EMPTY:
+ error_msg_and_die("invalid filter expression '%s'", str);
+ case F_BEGIN:
+ action_name = "trace";
+ main_part = begin;
+ /* fall through */
+ case F_QUAL_SET:
+ case F_QUAL_ARGS:
+ parse_qualify_action(action_name, main_part, args);
+ break;
+ case F_FILT_EXPR:
+ case F_FILT_ARGS:
+ case F_END:
+ if (parentheses_count != 0)
+ error_msg_and_die("missing ')' in '%s'", str);
+ if (expression_end)
+ *expression_end = '\0';
+ parse_filter_action(action_name, main_part, args);
+ break;
+ }
+ free(buf);
+}
diff --git a/filter_qualify.c b/filter_qualify.c
index 3765f656..51f1a2ba 100644
--- a/filter_qualify.c
+++ b/filter_qualify.c
@@ -181,27 +181,31 @@ parse_inject_common_args(char *str, struct inject_opts *const opts,
}
static void
-parse_read(const char *const str)
+parse_read(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("read");
struct filter *filter = create_filter(action, "fd");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("read action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-parse_write(const char *const str)
+parse_write(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("write");
struct filter *filter = create_filter(action, "fd");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("write action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-qualify_signals(const char *const str)
+qualify_signals(const char *const main_part, const char *const args)
{
/* Clear the set. */
if (signal_set.nslots)
@@ -209,89 +213,97 @@ qualify_signals(const char *const str)
sizeof(*signal_set.vec) * signal_set.nslots);
signal_set.not = false;
- parse_set(str, &signal_set, sigstr_to_uint, "signal");
+ parse_set(main_part, &signal_set, sigstr_to_uint, "signal");
+ if (args)
+ error_msg("signal action takes no arguments: '%s'", args);
}
static void
-parse_trace(const char *const str)
+parse_trace(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("trace");
struct filter *filter = create_filter(action, "syscall");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("trace action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-parse_abbrev(const char *const str)
+parse_abbrev(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("abbrev");
struct filter *filter = create_filter(action, "syscall");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("abbrev action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-parse_verbose(const char *const str)
+parse_verbose(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("verbose");
struct filter *filter = create_filter(action, "syscall");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("verbose action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-parse_raw(const char *const str)
+parse_raw(const char *const main_part, const char *const args)
{
struct filter_action *action = find_or_add_action("raw");
struct filter *filter = create_filter(action, "syscall");
- parse_filter(filter, str);
+ parse_filter(filter, main_part);
+ if (args)
+ error_msg("raw action takes no arguments: '%s'", args);
set_qualify_mode(action);
}
static void
-parse_inject_common_qualify(const char *const str, const bool fault_tokens_only,
- const char *const description)
+parse_inject_common_qualify(const char *const main_part, const char *const args,
+ const bool fault_tokens_only, const char *const description)
{
struct inject_opts *opts = xmalloc(sizeof(struct inject_opts));
- char *buf = xstrdup(str);
+ char *buf = args ? xstrdup(args) : NULL;
struct filter_action *action;
struct filter *filter;
- char *args = strchr(buf, ':');
-
- if (args)
- *(args++) = '\0';
action = find_or_add_action(fault_tokens_only ? "fault" : "inject");
filter = create_filter(action, "syscall");
- parse_filter(filter, buf);
+ parse_filter(filter, main_part);
set_qualify_mode(action);
- parse_inject_common_args(args, opts, ":", fault_tokens_only);
- if (!opts->init)
+ parse_inject_common_args(buf, opts, ":", fault_tokens_only);
+ if (!opts->init) {
error_msg_and_die("invalid %s '%s'", description,
args ? args : "");
- free(buf);
+ }
+ if (buf)
+ free(buf);
set_filter_action_priv_data(action, opts);
}
static void
-parse_fault(const char *const str)
+parse_fault(const char *const main_part, const char *const args)
{
- parse_inject_common_qualify(str, true, "fault argument");
+ parse_inject_common_qualify(main_part, args, true, "fault argument");
}
static void
-parse_inject(const char *const str)
+parse_inject(const char *const main_part, const char *const args)
{
- parse_inject_common_qualify(str, false, "inject argument");
+ parse_inject_common_qualify(main_part, args, false, "inject argument");
}
static const struct qual_options {
const char *name;
- void (*qualify)(const char *);
+ void (*qualify)(const char *, const char *);
} qual_options[] = {
{ "trace", parse_trace },
{ "t", parse_trace },
@@ -314,23 +326,26 @@ static const struct qual_options {
{ "inject", parse_inject },
};
+bool parsing_qualify_mode = false;
+
void
-parse_qualify_filter(const char *str)
+parse_qualify_action(const char *action_name, const char *main_part,
+ const char *args)
{
- const struct qual_options *opt = qual_options;
+ const struct qual_options *opt = NULL;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(qual_options); ++i) {
- const char *name = qual_options[i].name;
- const size_t len = strlen(name);
- const char *val = str_strip_prefix_len(str, name, len);
-
- if (val == str || *val != '=')
- continue;
- str = val + 1;
- opt = &qual_options[i];
- break;
+ if (!strcmp(action_name, qual_options[i].name)) {
+ opt = &qual_options[i];
+ break;
+ }
}
- opt->qualify(str);
+ if (!opt)
+ error_msg_and_die("invalid filter action '%s'", action_name);
+ /* Use qualify mode of set parsing. */
+ parsing_qualify_mode = true;
+ opt->qualify(main_part, args);
+ parsing_qualify_mode = false;
}
diff --git a/strace.c b/strace.c
index 6162d3b3..79c5397e 100644
--- a/strace.c
+++ b/strace.c
@@ -1580,7 +1580,7 @@ init(int argc, char *argv[])
#if DEFAULT_QUAL_FLAGS != (QUAL_TRACE | QUAL_ABBREV | QUAL_VERBOSE)
# error Bug in DEFAULT_QUAL_FLAGS
#endif
- parse_qualify_filter("signal=all");
+ filtering_parse("signal=all");
while ((c = getopt(argc, argv,
"+b:cCdfFhiqrtTvVwxyz"
#ifdef USE_LIBUNWIND
@@ -1647,7 +1647,7 @@ init(int argc, char *argv[])
show_fd_path++;
break;
case 'v':
- parse_qualify_filter("abbrev=none");
+ filtering_parse("abbrev=none");
break;
case 'V':
print_version();
@@ -1662,7 +1662,7 @@ init(int argc, char *argv[])
error_opt_arg(c, optarg);
break;
case 'e':
- parse_qualify_filter(optarg);
+ filtering_parse(optarg);
break;
case 'o':
outfname = optarg;
diff --git a/tests/filtering_syscall-syntax.test b/tests/filtering_syscall-syntax.test
index 2a4125ae..3f8db02b 100755
--- a/tests/filtering_syscall-syntax.test
+++ b/tests/filtering_syscall-syntax.test
@@ -54,25 +54,11 @@ for arg in '' , ,, ,,, \! \!, \
check_syscall "$arg" "$arg"
done
-# Temporary workaround
for arg in : :: ::: \
; do
- check_e "invalid system call '$arg'" -e trace="$arg"
- check_e "invalid system call '$arg'" -e abbrev="$arg"
- check_e "invalid system call '$arg'" -e verbose="$arg"
- check_e "invalid system call '$arg'" -e raw="$arg"
- check_e "invalid system call ''" -e inject="$arg"
- check_e "invalid system call ''" -e fault="$arg"
+ check_syscall "" "$arg"
done
-# Temporary workaround for '!:' check
-check_e "invalid system call ':'" -e trace=\!:
-check_e "invalid system call ':'" -e abbrev=\!:
-check_e "invalid system call ':'" -e verbose=\!:
-check_e "invalid system call ':'" -e raw=\!:
-check_e "invalid system call '!'" -e inject=\!:
-check_e "invalid system call '!'" -e fault=\!:
-
# invalid syscall with inversion
for arg in -1 -2 -3 -4 -5 \
invalid_syscall_name \
@@ -99,6 +85,7 @@ for arg in file,nonsense \
done
# special cases
+check_syscall "!" \!:
check_syscall "!" 1,\!
check_syscall "!open" 1,\!open
check_syscall "none" 1,none
--
2.11.0
More information about the Strace-devel
mailing list