Fix: handle errors gracefully

- Return errors in io struct generator rather than using assertions,
- check for NULL concatenate string return values,
- fix memleak on ctf_trace_declaration_visit error path.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
index fe0b6b4d9ed8db460cc9d5152d5e9a16805130a8..17479ebaec39f384056ce479d68db3552c6c4560 100644 (file)
--- a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
+++ b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
@@ -95,10 +95,11 @@ char *concatenate_unary_strings(struct bt_list_head *head)
        bt_list_for_each_entry(node, head, siblings) {
                char *src_string;
 
-               assert(node->type == NODE_UNARY_EXPRESSION);
-               assert(node->u.unary_expression.type == UNARY_STRING);
-               assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
-                       ^ (i != 0));
+               if (node->type != NODE_UNARY_EXPRESSION
+                               || node->u.unary_expression.type != UNARY_STRING
+                               || !((node->u.unary_expression.link != UNARY_LINK_UNKNOWN)
+                                       ^ (i == 0)))
+                       return NULL;
                switch (node->u.unary_expression.link) {
                case UNARY_DOTLINK:
                        g_string_append(str, ".");
@@ -129,10 +130,11 @@ GQuark get_map_clock_name_value(struct bt_list_head *head)
        bt_list_for_each_entry(node, head, siblings) {
                char *src_string;
 
-               assert(node->type == NODE_UNARY_EXPRESSION);
-               assert(node->u.unary_expression.type == UNARY_STRING);
-               assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
-                       ^ (i != 0));
+               if (node->type != NODE_UNARY_EXPRESSION
+                       || node->u.unary_expression.type != UNARY_STRING
+                       || !((node->u.unary_expression.link != UNARY_LINK_UNKNOWN)
+                               ^ (i == 0)))
+                       return 0;
                /* needs to be chained with . */
                switch (node->u.unary_expression.link) {
                case UNARY_DOTLINK:
@@ -184,10 +186,11 @@ int get_unary_unsigned(struct bt_list_head *head, uint64_t *value)
        int i = 0;
 
        bt_list_for_each_entry(node, head, siblings) {
-               assert(node->type == NODE_UNARY_EXPRESSION);
-               assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
-               assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
-               assert(i == 0);
+               if (node->type != NODE_UNARY_EXPRESSION
+                               || node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
+                               || node->u.unary_expression.link != UNARY_LINK_UNKNOWN
+                               || i != 0)
+                       return -EINVAL;
                *value = node->u.unary_expression.u.unsigned_constant;
                i++;
        }
@@ -215,11 +218,12 @@ int get_unary_signed(struct bt_list_head *head, int64_t *value)
        int i = 0;
 
        bt_list_for_each_entry(node, head, siblings) {
-               assert(node->type == NODE_UNARY_EXPRESSION);
-               assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT
-                       || node->u.unary_expression.type == UNARY_SIGNED_CONSTANT);
-               assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
-               assert(i == 0);
+               if (node->type != NODE_UNARY_EXPRESSION
+                               || node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
+                               || (node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT && node->u.unary_expression.type != UNARY_SIGNED_CONSTANT)
+                               || node->u.unary_expression.link != UNARY_LINK_UNKNOWN
+                               || i != 0)
+                       return -EINVAL;
                switch (node->u.unary_expression.type) {
                case UNARY_UNSIGNED_CONSTANT:
                        *value = (int64_t) node->u.unary_expression.u.unsigned_constant;
@@ -228,7 +232,7 @@ int get_unary_signed(struct bt_list_head *head, int64_t *value)
                        *value = node->u.unary_expression.u.signed_constant;
                        break;
                default:
-                       assert(0);
+                       return -EINVAL;
                }
                i++;
        }
@@ -245,10 +249,11 @@ int get_unary_uuid(struct bt_list_head *head, unsigned char *uuid)
        bt_list_for_each_entry(node, head, siblings) {
                const char *src_string;
 
-               assert(node->type == NODE_UNARY_EXPRESSION);
-               assert(node->u.unary_expression.type == UNARY_STRING);
-               assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
-               assert(i == 0);
+               if (node->type != NODE_UNARY_EXPRESSION
+                               || node->u.unary_expression.type != UNARY_STRING
+                               || node->u.unary_expression.link != UNARY_LINK_UNKNOWN
+                               || i != 0)
+                       return -EINVAL;
                src_string = node->u.unary_expression.u.string;
                ret = babeltrace_uuid_parse(src_string, uuid);
        }
@@ -272,7 +277,8 @@ struct ctf_clock *trace_clock_lookup(struct ctf_trace *trace, GQuark clock_name)
 static
 int visit_type_specifier(FILE *fd, struct ctf_node *type_specifier, GString *str)
 {
-       assert(type_specifier->type == NODE_TYPE_SPECIFIER);
+       if (type_specifier->type != NODE_TYPE_SPECIFIER)
+               return -EINVAL;
 
        switch (type_specifier->u.type_specifier.type) {
        case TYPESPEC_VOID:
@@ -426,7 +432,9 @@ struct bt_declaration *ctf_type_declarator_visit(FILE *fd, int depth,
         */
 
        if (node_type_declarator) {
-               assert(node_type_declarator->u.type_declarator.type != TYPEDEC_UNKNOWN);
+               if (node_type_declarator->u.type_declarator.type == TYPEDEC_UNKNOWN) {
+                       return NULL;
+               }
 
                /* TODO: gcc bitfields not supported yet. */
                if (node_type_declarator->u.type_declarator.bitfield_len != NULL) {
@@ -500,7 +508,9 @@ struct bt_declaration *ctf_type_declarator_visit(FILE *fd, int depth,
                }
                first = _bt_list_first_entry(&node_type_declarator->u.type_declarator.u.nested.length, 
                                struct ctf_node, siblings);
-               assert(first->type == NODE_UNARY_EXPRESSION);
+               if (first->type != NODE_UNARY_EXPRESSION) {
+                       return NULL;
+               }
 
                switch (first->u.unary_expression.type) {
                case UNARY_UNSIGNED_CONSTANT:
@@ -526,6 +536,8 @@ struct bt_declaration *ctf_type_declarator_visit(FILE *fd, int depth,
                        char *length_name = concatenate_unary_strings(&node_type_declarator->u.type_declarator.u.nested.length);
                        struct declaration_sequence *sequence_declaration;
 
+                       if (!length_name)
+                               return NULL;
                        sequence_declaration = bt_sequence_declaration_new(length_name, nested_declaration, declaration_scope);
                        if (!sequence_declaration) {
                                fprintf(fd, "[error] %s: cannot create sequence declaration.\n", __func__);
@@ -538,7 +550,7 @@ struct bt_declaration *ctf_type_declarator_visit(FILE *fd, int depth,
                        break;
                }
                default:
-                       assert(0);
+                       return NULL;
                }
 
                /* Pass it as content of outer container */
@@ -773,7 +785,7 @@ int ctf_struct_declaration_list_visit(FILE *fd, int depth,
                break;
        default:
                fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
-               assert(0);
+               return -EINVAL;
        }
        return 0;
 }
@@ -817,7 +829,7 @@ int ctf_variant_declaration_list_visit(FILE *fd, int depth,
                break;
        default:
                fprintf(fd, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
-               assert(0);
+               return -EINVAL;
        }
        return 0;
 }
@@ -838,7 +850,8 @@ struct bt_declaration *ctf_declaration_struct_visit(FILE *fd,
         * declaration: ref is only taken upon definition.
         */
        if (!has_body) {
-               assert(name);
+               if (!name)
+                       return NULL;
                struct_declaration =
                        bt_lookup_struct_declaration(g_quark_from_string(name),
                                                  declaration_scope);
@@ -883,7 +896,8 @@ struct bt_declaration *ctf_declaration_struct_visit(FILE *fd,
                        ret = bt_register_struct_declaration(g_quark_from_string(name),
                                        struct_declaration,
                                        declaration_scope);
-                       assert(!ret);
+                       if (ret)
+                               return NULL;
                }
                return &struct_declaration->p;
        }
@@ -910,7 +924,8 @@ struct bt_declaration *ctf_declaration_variant_visit(FILE *fd,
         * declaration: ref is only taken upon definition.
         */
        if (!has_body) {
-               assert(name);
+               if (!name)
+                       return NULL;
                untagged_variant_declaration =
                        bt_lookup_variant_declaration(g_quark_from_string(name),
                                                   declaration_scope);
@@ -941,7 +956,8 @@ struct bt_declaration *ctf_declaration_variant_visit(FILE *fd,
                        ret = bt_register_variant_declaration(g_quark_from_string(name),
                                        untagged_variant_declaration,
                                        declaration_scope);
-                       assert(!ret);
+                       if (ret)
+                               return NULL;
                }
        }
        /*
@@ -979,7 +995,8 @@ int ctf_enumerator_list_visit(FILE *fd, int depth,
                bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
                        int64_t *target;
 
-                       assert(iter->type == NODE_UNARY_EXPRESSION);
+                       if (iter->type != NODE_UNARY_EXPRESSION)
+                               return -EINVAL;
                        if (nr_vals == 0)
                                target = &start;
                        else
@@ -1015,7 +1032,8 @@ int ctf_enumerator_list_visit(FILE *fd, int depth,
                bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
                        uint64_t *target;
 
-                       assert(iter->type == NODE_UNARY_EXPRESSION);
+                       if (iter->type != NODE_UNARY_EXPRESSION)
+                               return -EINVAL;
                        if (nr_vals == 0)
                                target = &start;
                        else
@@ -1074,7 +1092,8 @@ struct bt_declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
         * declaration: ref is only taken upon definition.
         */
        if (!has_body) {
-               assert(name);
+               if (!name)
+                       return NULL;
                enum_declaration =
                        bt_lookup_enum_declaration(g_quark_from_string(name),
                                                declaration_scope);
@@ -1135,7 +1154,8 @@ struct bt_declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
                        ret = bt_register_enum_declaration(g_quark_from_string(name),
                                        enum_declaration,
                                        declaration_scope);
-                       assert(!ret);
+                       if (ret)
+                               return NULL;
                        bt_declaration_unref(&enum_declaration->p);
                }
                return &enum_declaration->p;
@@ -1286,7 +1306,8 @@ struct bt_declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
 
                left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
                right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
-               assert(left->u.unary_expression.type == UNARY_STRING);
+               if (left->u.unary_expression.type != UNARY_STRING)
+                       return NULL;
                if (!strcmp(left->u.unary_expression.u.string, "signed")) {
                        signedness = get_boolean(fd, depth, right);
                        if (signedness < 0)
@@ -1468,7 +1489,8 @@ struct bt_declaration *ctf_declaration_floating_point_visit(FILE *fd, int depth,
 
                left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
                right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
-               assert(left->u.unary_expression.type == UNARY_STRING);
+               if (left->u.unary_expression.type != UNARY_STRING)
+                       return NULL;
                if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
                        byte_order = get_byte_order(fd, depth, right, trace);
                        if (byte_order < 0)
@@ -1546,7 +1568,8 @@ struct bt_declaration *ctf_declaration_string_visit(FILE *fd, int depth,
 
                left = _bt_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
                right = _bt_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);
-               assert(left->u.unary_expression.type == UNARY_STRING);
+               if (left->u.unary_expression.type != UNARY_STRING)
+                       return NULL;
                if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
                        if (right->u.unary_expression.type != UNARY_STRING) {
                                fprintf(fd, "[error] %s: encoding: expecting string\n",
@@ -1576,11 +1599,13 @@ struct bt_declaration *ctf_type_specifier_list_visit(FILE *fd,
        struct ctf_node *first;
        struct ctf_node *node;
 
-       assert(type_specifier_list->type == NODE_TYPE_SPECIFIER_LIST);
+       if (type_specifier_list->type != NODE_TYPE_SPECIFIER_LIST)
+               return NULL;
 
        first = _bt_list_first_entry(&type_specifier_list->u.type_specifier_list.head, struct ctf_node, siblings);
 
-       assert(first->type == NODE_TYPE_SPECIFIER);
+       if (first->type != NODE_TYPE_SPECIFIER)
+               return NULL;
 
        node = first->u.type_specifier.node;
 
@@ -1669,6 +1694,8 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "name")) {
                        char *right;
 
@@ -1905,6 +1932,8 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "id")) {
                        if (CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {
                                fprintf(fd, "[error] %s: id already declared in stream declaration\n", __func__);
@@ -2085,6 +2114,8 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "major")) {
                        if (CTF_TRACE_FIELD_IS_SET(trace, major)) {
                                fprintf(fd, "[error] %s: major already declared in trace declaration\n", __func__);
@@ -2135,8 +2166,10 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
 
                        right = _bt_list_first_entry(&node->u.ctf_expression.right, struct ctf_node, siblings);
                        byte_order = get_trace_byte_order(fd, depth, right);
-                       if (byte_order < 0)
-                               return -EINVAL;
+                       if (byte_order < 0) {
+                               ret = -EINVAL;
+                               goto error;
+                       }
 
                        if (CTF_TRACE_FIELD_IS_SET(trace, byte_order)
                                && byte_order != trace->byte_order) {
@@ -2262,6 +2295,8 @@ int ctf_clock_declaration_visit(FILE *fd, int depth, struct ctf_node *node,
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "name")) {
                        char *right;
 
@@ -2480,6 +2515,8 @@ int ctf_callsite_declaration_visit(FILE *fd, int depth, struct ctf_node *node,
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "name")) {
                        char *right;
 
@@ -2651,6 +2688,8 @@ int ctf_env_declaration_visit(FILE *fd, int depth, struct ctf_node *node,
                char *left;
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
+               if (!left)
+                       return -EINVAL;
                if (!strcmp(left, "vpid")) {
                        uint64_t v;
 
@@ -2766,6 +2805,11 @@ int ctf_env_declaration_visit(FILE *fd, int depth, struct ctf_node *node,
                                char *right;
 
                                right = concatenate_unary_strings(&node->u.ctf_expression.right);
+                               if (!right) {
+                                       fprintf(fd, "[warning] %s: unexpected unary expression for env\n", __func__);
+                                       ret = -EINVAL;
+                                       goto error;
+                               }
                                printf_verbose("env.%s = \"%s\"\n", left, right);
                                g_free(right);
                        } else if (is_unary_unsigned(&node->u.ctf_expression.right)) {
@@ -2773,14 +2817,16 @@ int ctf_env_declaration_visit(FILE *fd, int depth, struct ctf_node *node,
                                int ret;
 
                                ret = get_unary_unsigned(&node->u.ctf_expression.right, &v);
-                               assert(ret == 0);
+                               if (ret)
+                                       goto error;
                                printf_verbose("env.%s = %" PRIu64 "\n", left, v);
                        } else if (is_unary_signed(&node->u.ctf_expression.right)) {
                                int64_t v;
                                int ret;
 
                                ret = get_unary_signed(&node->u.ctf_expression.right, &v);
-                               assert(ret == 0);
+                               if (ret)
+                                       goto error;
                                printf_verbose("env.%s = %" PRId64 "\n", left, v);
                        } else {
                                printf_verbose("%s: attribute \"%s\" has unknown type.\n", __func__, left);