Filter: fix warnings and memory leak

Author: sedmicha

include/libfds/ipfix_filter.h

@@ -12,47 +12,47 @@ extern "C" {
 typedef struct fds_ipfix_filter fds_ipfix_filter_t;
 
 /**
- * 
+ *
  * Creates an IPFIX filter from an expression.
  *
  * \param[out] ipfil    Pointer to where to allocate and construct the filter
  * \param[in]  iemgr    The information elements manager
  * \param[in]  expr     The filter expression
- * 
+ *
  * On error, more detailed information about the error can be obtained using fds_filter_ipfix_get_error.
  * After the filter structure is destroyed the error is destroyed along with it!
  *
  * \return FDS_OK on success, else one of FDS_ERR_NOMEM, FDS_ERR_SYNTAX, FDS_ERR_SEMANTIC.
  */
-FDS_API int 
-fds_ipfix_filter_create(fds_ipfix_filter_t **ipxfil, fds_iemgr_t *iemgr, const char *expr);
+FDS_API int
+fds_ipfix_filter_create(fds_ipfix_filter_t **ipxfil, const fds_iemgr_t *iemgr, const char *expr);
 
 /**
  * Evaluates the IPFIX filter using the provided data record.
- * 
+ *
  * \param[in] ipxfil  The IPFIX filter
- * \param[in] record  A data record 
+ * \param[in] record  A data record
  *
- * \return true if the data record passes the filter, false if not 
+ * \return true if the data record passes the filter, false if not
  */
 FDS_API bool
 fds_ipfix_filter_eval(struct fds_ipfix_filter *ipxfil, struct fds_drec *record);
 
 /**
  * Destroys the IPFIX filter.
- * 
+ *
  * \param[in] ipxfil  The filter to be destroyed.
  */
 FDS_API void
 fds_ipfix_filter_destroy(fds_ipfix_filter_t *ipxfil);
 
 /**
  * Gets the error from an IPFIX filter.
- * 
+ *
  * If the filter parameter is NULL then memory error is assumed.
- * 
+ *
  * \param[in] ipxfil  The IPFIX filter
- * 
+ *
  * \return Pointer to the error, or NULL if there is no error.
  */
 FDS_API const char *

src/filter/common.h

@@ -5,7 +5,7 @@
  * \date 2020
  */
 
-/* 
+/*
  * Copyright (C) 2020 CESNET, z.s.p.o.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,7 +47,7 @@
 #ifdef FDS_FILTER_DEBUG
 #define IF_DEBUG(X) X
 #else
-#define IF_DEBUG(X) 
+#define IF_DEBUG(X)
 #endif
 
 #define CONST_ARR_SIZE(x)   (sizeof(x) / sizeof((x)[0]))

src/filter/error.c

@@ -42,7 +42,7 @@
 
 #include "error.h"
 
-const fds_filter_error_s memory_error = { .code = FDS_ERR_NOMEM, .msg = "out of memory" };
+fds_filter_error_s memory_error = { .code = FDS_ERR_NOMEM, .msg = "out of memory" };
 
 error_t const NO_ERROR = NULL;
 error_t const MEMORY_ERROR = &memory_error;

src/filter/eval_common.h

@@ -116,6 +116,7 @@ destroy_eval_node(eval_node_s *en)
     }
     if (en->opcode == EVAL_OP_NONE && en->destructor_fn) {
         en->destructor_fn(&en->value);
+        memset(&en->value, 0, sizeof(fds_filter_value_u));
     }
     free(en);
 }
@@ -161,7 +162,6 @@ print_eval_tree_rec(FILE *out, eval_node_s *node, int indent_level)
 
     PRINT_INDENT();
 
-    fprintf(out, "(%s, ", eval_opcode_to_str(node->opcode));
     fprintf(out, "data type: %s, value: ", data_type_to_str(node->datatype));
 
     print_value(out, node->datatype, &node->value);

src/filter/eval_generator.c

@@ -65,6 +65,7 @@ delete_value_from_et(fds_filter_value_u *value, eval_node_s *tree)
     // if the value matches by value zero it out
     if (memcmp(&tree->value, value, sizeof(fds_filter_value_u)) == 0) {
         tree->value = (fds_filter_value_u){0};
+        tree->destructor_fn = NULL;
     }
 }
 
@@ -167,7 +168,7 @@ list_to_literal(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, fds_filter_
     }
 
     // Evaluate each list item node and populate the list
-    int idx = 0;
+    uint64_t idx = 0;
     for (fds_filter_ast_node_s *li = ast->child; li != NULL; li = li->next) {
         assert(idx < out_list->len);
 
@@ -222,6 +223,8 @@ process_root_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool seco
 static error_t
 process_constructor_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool second_run, eval_node_s **out_eval_node)
 {
+    (void) second_run;
+
     // Must be const, should be assured by semantic analysis
     assert(ast->flags & FDS_FAF_CONST_SUBTREE);
 
@@ -265,6 +268,9 @@ process_constructor_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bo
 static error_t
 process_exists_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool second_run, eval_node_s **out_eval_node)
 {
+    (void) second_run;
+    (void) opts;
+
     // Must have a __name__ node as its only child
     assert(ast_node_symbol_is(ast->child, "__name__"));
 
@@ -286,6 +292,8 @@ process_exists_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool se
 static error_t
 process_name_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool second_run, eval_node_s **out_eval_node)
 {
+    (void) second_run;
+
     eval_node_s *en = create_eval_node();
     if (!en) {
         return MEMORY_ERROR;
@@ -309,6 +317,8 @@ process_name_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool seco
 static error_t
 process_literal_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool second_run, eval_node_s **out_eval_node)
 {
+    (void) second_run;
+
     eval_node_s *en = create_eval_node();
     if (!en) {
         return MEMORY_ERROR;
@@ -332,6 +342,8 @@ process_literal_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool s
 static error_t
 process_list_node(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool second_run, eval_node_s **out_eval_node)
 {
+    (void) second_run;
+
     eval_node_s *en = create_eval_node();
     if (!en) {
         return MEMORY_ERROR;
@@ -473,9 +485,17 @@ generate_eval_tree(fds_filter_ast_node_s *ast, fds_filter_opts_t *opts, bool sec
             en->opcode = EVAL_OP_NONE;
             IF_DEBUG(en->datatype = ast->datatype;)
             error_t err = ast_to_literal(ast, opts, &en->value);
+            if (err != NO_ERROR) {
+                destroy_eval_node(en);
+                return err;
+            }
+            fds_filter_op_s *destructor = find_destructor(opts->op_list, ast->datatype);
+            if (destructor) {
+                en->destructor_fn = destructor->destructor_fn;
+            }
             *out_eval_node = en;
 
-            // ast->flags &= ~FDS_FAF_DESTROY_VAL;
+            ast->flags &= ~FDS_FAF_DESTROY_VAL;
 
             return NO_ERROR;
         }

src/filter/opts.c

@@ -84,6 +84,7 @@ dummy_data_callback(void *user_ctx, bool reset_ctx, int id, void *data, fds_filt
     return FDS_ERR_NOTFOUND;
 }
 
+/*
 static void
 print_op_list(FILE *out, fds_filter_op_s *op_list)
 {
@@ -92,6 +93,7 @@ print_op_list(FILE *out, fds_filter_op_s *op_list)
         fprintf(out, "\n");
     }
 }
+*/
 
 static inline int
 op_list_count(const fds_filter_op_s *op_list)

src/filter/parser.c

@@ -112,7 +112,7 @@ const char *name_prefixes[] = {
 static bool
 token_is_name_prefix(struct token_s token)
 {
-    for (int i = 0; i < CONST_ARR_SIZE(name_prefixes); i++) {
+    for (size_t i = 0; i < CONST_ARR_SIZE(name_prefixes); i++) {
         if (token_is_symbol(token, name_prefixes[i])) {
             return true;
         }
@@ -124,7 +124,7 @@ token_is_name_prefix(struct token_s token)
 struct operator_s *
 find_operator(enum op_kind_e kind, const char *symbol)
 {
-    for (int i = 0; i < CONST_ARR_SIZE(op_parse_def_table); i++) {
+    for (size_t i = 0; i < CONST_ARR_SIZE(op_parse_def_table); i++) {
         struct operator_s *o = &op_parse_def_table[i];
         if (o->kind == kind && strcmp(o->symbol, symbol) == 0) {
             return o;
@@ -193,9 +193,9 @@ parse_infix_expr(struct scanner_s *scanner, int prec, fds_filter_ast_node_s **ou
             // we want the recursive parse call to only match the 2 and leave the next + to end up with a parse tree:
             //
             //                                     (+) <-- the call one level above in the recursive call tree is creating this node
-            //                                    /    \
+            //                                    /    \                                                                            .
             //   we are creating this node ---> (+)    (4)
-            //                                 /    \
+            //                                 /    \                                                                               .
             //    this is our left expr ---> (2)     (3) <--- this part is returned from the following call
             //
             err = parse_infix_expr(scanner, o->prec + 1, &right_expr);
@@ -210,9 +210,9 @@ parse_infix_expr(struct scanner_s *scanner, int prec, fds_filter_ast_node_s **ou
             // the following ** to end up with a parse tree:
             //
             //                                 (**) <--- we are creating this node
-            //                                /    \
+            //                                /    \                                                      .
             //       this is our left --->  (2)     (**) <--- this part is returned from the following call
-            //                                     /    \
+            //                                     /    \                                                 .
             //                                   (3)     (4)
             err =  parse_infix_expr(scanner, o->prec, &right_expr);
         }
@@ -361,7 +361,6 @@ parse_prefix_expr(struct scanner_s *scanner, fds_filter_ast_node_s **out_ast)
             }
 
             // create the list item node
-            fds_filter_ast_node_s *parent_node = *item_node_ptr;
             *item_node_ptr = create_unary_ast_node("__listitem__", expr_node);
             if (*item_node_ptr == NULL) {
                 destroy_ast(list_node);
@@ -405,7 +404,6 @@ parse_prefix_expr(struct scanner_s *scanner, fds_filter_ast_node_s **out_ast)
             fds_filter_ast_node_s *expr;
             err = parse_infix_expr(scanner, o->prec + 1, &expr);
             if (err != NO_ERROR) {
-
                 return err;
             }
 
@@ -414,6 +412,8 @@ parse_prefix_expr(struct scanner_s *scanner, fds_filter_ast_node_s **out_ast)
                 destroy_ast(expr);
                 return MEMORY_ERROR;
             }
+            ast->cursor_begin = cursor_begin;
+            ast->cursor_end = token.cursor_end;
 
             *out_ast = ast;
             return NO_ERROR;