[babeltrace.git] / src / plugins / ctf / common / metadata / decoder.cpp

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2016-2017 Philippe Proulx <pproulx@efficios.com>
 */

#define BT_COMP_LOG_SELF_COMP       (mdec->config.self_comp)
#define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
#define BT_LOG_OUTPUT_LEVEL         (mdec->config.log_level)
#define BT_LOG_TAG                  "PLUGIN/CTF/META/DECODER"
#include "logging/comp-logging.h"

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include "common/assert.h"
#include "common/uuid.h"
#include "compat/memstream.h"
#include <babeltrace2/babeltrace.h>
#include <glib.h>
#include <string.h>

#include "ast.hpp"
#include "decoder.hpp"
#include "scanner.hpp"
#include "logging.hpp"
#include "parser-wrap.hpp"
#include "decoder-packetized-file-stream-to-buf.hpp"

#define TSDL_MAGIC 0x75d11d57

struct ctf_metadata_decoder
{
    struct ctf_scanner *scanner;
    GString *text;
    struct ctf_visitor_generate_ir *visitor;
    bt_uuid_t uuid;
    bool is_uuid_set;
    int bo;
    struct ctf_metadata_decoder_config config;
    struct meta_log_config log_cfg;
    bool has_checked_plaintext_signature;
};

struct packet_header
{
    uint32_t magic;
    bt_uuid_t uuid;
    uint32_t checksum;
    uint32_t content_size;
    uint32_t packet_size;
    uint8_t compression_scheme;
    uint8_t encryption_scheme;
    uint8_t checksum_scheme;
    uint8_t major;
    uint8_t minor;
} __attribute__((__packed__));

BT_HIDDEN
int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized, int *byte_order,
                                       bt_logging_level log_level, bt_self_component *self_comp)
{
    uint32_t magic;
    size_t len;
    int ret = 0;

    *is_packetized = false;
    len = fread(&magic, sizeof(magic), 1, fp);
    if (len != 1) {
        BT_COMP_LOG_CUR_LVL(
            BT_LOG_INFO, log_level, self_comp,
            "Cannot read first metadata packet header: assuming the stream is not packetized.");
        ret = -1;
        goto end;
    }

    if (byte_order) {
        if (magic == TSDL_MAGIC) {
            *is_packetized = true;
            *byte_order = BYTE_ORDER;
        } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
            *is_packetized = true;
            *byte_order = BYTE_ORDER == BIG_ENDIAN ? LITTLE_ENDIAN : BIG_ENDIAN;
        }
    }

end:
    rewind(fp);

    return ret;
}

BT_HIDDEN
struct ctf_metadata_decoder *
ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config)
{
    struct ctf_metadata_decoder *mdec = g_new0(struct ctf_metadata_decoder, 1);

    BT_ASSERT(config);
    BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
                        "Creating CTF metadata decoder: "
                        "clock-class-offset-s=%" PRId64 ", "
                        "clock-class-offset-ns=%" PRId64,
                        config->clock_class_offset_s, config->clock_class_offset_ns);

    if (!mdec) {
        BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level, config->self_comp,
                            "Failed to allocate one CTF metadata decoder.");
        goto end;
    }

    mdec->log_cfg.log_level = config->log_level;
    mdec->log_cfg.self_comp = config->self_comp;
    mdec->log_cfg.self_comp_class = config->self_comp_class;
    mdec->scanner = ctf_scanner_alloc();
    if (!mdec->scanner) {
        _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
                                                 "mdec-addr=%p",
                                                 mdec);
        goto error;
    }

    mdec->text = g_string_new(NULL);
    if (!mdec->text) {
        _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one GString: "
                                                 "mdec-addr=%p",
                                                 mdec);
        goto error;
    }

    mdec->bo = -1;
    mdec->config = *config;
    mdec->visitor = ctf_visitor_generate_ir_create(config);
    if (!mdec->visitor) {
        _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
                                                 "mdec-addr=%p",
                                                 mdec);
        goto error;
    }

    BT_COMP_LOGD("Creating CTF metadata decoder: "
                 "clock-class-offset-s=%" PRId64 ", "
                 "clock-class-offset-ns=%" PRId64 ", addr=%p",
                 config->clock_class_offset_s, config->clock_class_offset_ns, mdec);
    goto end;

error:
    ctf_metadata_decoder_destroy(mdec);
    mdec = NULL;

end:
    return mdec;
}

BT_HIDDEN
void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
{
    if (!mdec) {
        return;
    }

    if (mdec->scanner) {
        ctf_scanner_free(mdec->scanner);
    }

    if (mdec->text) {
        g_string_free(mdec->text, TRUE);
    }

    BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
    ctf_visitor_generate_ir_destroy(mdec->visitor);
    g_free(mdec);
}

BT_HIDDEN
enum ctf_metadata_decoder_status
ctf_metadata_decoder_append_content(struct ctf_metadata_decoder *mdec, FILE *fp)
{
    enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
    int ret;
    char *buf = NULL;
    bool close_fp = false;
    long start_pos = -1;
    bool is_packetized;

    BT_ASSERT(mdec);
    ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo, mdec->config.log_level,
                                             mdec->config.self_comp);
    if (ret) {
        status = CTF_METADATA_DECODER_STATUS_ERROR;
        goto end;
    }

    if (is_packetized) {
        BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
        ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
            fp, &buf, mdec->bo, &mdec->is_uuid_set, mdec->uuid, mdec->config.log_level,
            mdec->config.self_comp, mdec->config.self_comp_class);
        if (ret) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
                "Cannot decode packetized metadata packets to metadata text: "
                "mdec-addr=%p, ret=%d",
                mdec, ret);
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        if (strlen(buf) == 0) {
            /* An empty metadata packet is OK. */
            goto end;
        }

        /* Convert the real file pointer to a memory file pointer */
        fp = bt_fmemopen(buf, strlen(buf), "rb");
        close_fp = true;
        if (!fp) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
                                                     "mdec-addr=%p",
                                                     strerror(errno), mdec);
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }
    } else if (!mdec->has_checked_plaintext_signature) {
        unsigned int major, minor;
        ssize_t nr_items;
        const long init_pos = ftell(fp);

        BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);

        if (init_pos < 0) {
            BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
                                            "Failed to get current file position", ".");
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        /* Check text-only metadata header and version */
        nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
        if (nr_items < 2) {
            BT_COMP_LOGW(
                "Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
                "mdec-addr=%p",
                mdec);
        }

        BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);

        if (!ctf_metadata_decoder_is_packet_version_valid(major, minor)) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
                "Invalid metadata version found in plain text signature: "
                "version=%u.%u, mdec-addr=%p",
                major, minor, mdec);
            status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
            goto end;
        }

        if (fseek(fp, init_pos, SEEK_SET)) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
                "Cannot seek metadata file stream to initial position: %s: "
                "mdec-addr=%p",
                strerror(errno), mdec);
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        mdec->has_checked_plaintext_signature = true;
    }

#if YYDEBUG
    if (BT_LOG_ON_TRACE) {
        yydebug = 1;
    }
#endif

    /* Save the file's position: we'll seek back to append the plain text */
    BT_ASSERT(fp);

    if (mdec->config.keep_plain_text) {
        start_pos = ftell(fp);
    }

    /* Append the metadata text content */
    ret = ctf_scanner_append_ast(mdec->scanner, fp);
    if (ret) {
        _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
            "Cannot create the metadata AST out of the metadata text: "
            "mdec-addr=%p",
            mdec);
        status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
        goto end;
    }

    /* We know it's complete: append plain text */
    if (mdec->config.keep_plain_text) {
        BT_ASSERT(start_pos != -1);
        ret = fseek(fp, start_pos, SEEK_SET);
        if (ret) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
                                                     ret, mdec);
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
        if (ret) {
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
                                                     "ret=%d, mdec-addr=%p",
                                                     ret, mdec);
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }
    }

    ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root, &mdec->log_cfg);
    if (ret) {
        _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
                                                 "mdec-addr=%p",
                                                 mdec);
        status = CTF_METADATA_DECODER_STATUS_ERROR;
        goto end;
    }

    if (mdec->config.create_trace_class) {
        ret = ctf_visitor_generate_ir_visit_node(mdec->visitor, &mdec->scanner->ast->root);
        switch (ret) {
        case 0:
            /* Success */
            break;
        case -EINCOMPLETE:
            BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
                         "mdec-addr=%p",
                         mdec);
            status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
            goto end;
        default:
            _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
                "Failed to visit AST node to create CTF IR objects: "
                "mdec-addr=%p, ret=%d",
                mdec, ret);
            status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
            goto end;
        }
    }

end:
#if YYDEBUG
    yydebug = 0;
#endif

    if (fp && close_fp) {
        if (fclose(fp)) {
            BT_COMP_LOGE("Cannot close metadata file stream: "
                         "mdec-addr=%p",
                         mdec);
        }
    }

    free(buf);

    return status;
}

BT_HIDDEN
bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(struct ctf_metadata_decoder *mdec)
{
    BT_ASSERT_DBG(mdec);
    BT_ASSERT_DBG(mdec->config.create_trace_class);
    return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
}

BT_HIDDEN
struct ctf_trace_class *
ctf_metadata_decoder_borrow_ctf_trace_class(struct ctf_metadata_decoder *mdec)
{
    BT_ASSERT_DBG(mdec);
    BT_ASSERT_DBG(mdec->config.create_trace_class);
    return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
}

BT_HIDDEN
const char *ctf_metadata_decoder_get_text(struct ctf_metadata_decoder *mdec)
{
    BT_ASSERT_DBG(mdec);
    BT_ASSERT_DBG(mdec->config.keep_plain_text);
    return mdec->text->str;
}

BT_HIDDEN
int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
{
    BT_ASSERT_DBG(mdec);
    return mdec->bo;
}

BT_HIDDEN
int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
{
    int ret = 0;

    BT_ASSERT_DBG(mdec);

    if (!mdec->is_uuid_set) {
        ret = -1;
        goto end;
    }

    bt_uuid_copy(uuid, mdec->uuid);

end:
    return ret;
}

static enum ctf_metadata_decoder_status find_uuid_in_trace_decl(struct ctf_metadata_decoder *mdec,
                                                                struct ctf_node *trace_node,
                                                                bt_uuid_t uuid)
{
    enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
    struct ctf_node *entry_node;
    struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
    char *left = NULL;

    bt_list_for_each_entry (entry_node, decl_list, siblings) {
        if (entry_node->type == NODE_CTF_EXPRESSION) {
            int ret;

            left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
            if (!left) {
                _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
                status = CTF_METADATA_DECODER_STATUS_ERROR;
                goto end;
            }

            if (strcmp(left, "uuid") == 0) {
                ret = ctf_ast_get_unary_uuid(&entry_node->u.ctf_expression.right, uuid,
                                             mdec->config.log_level, mdec->config.self_comp);
                if (ret) {
                    _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
                    status = CTF_METADATA_DECODER_STATUS_ERROR;
                    goto end;
                }

                goto end;
            }

            g_free(left);
            left = NULL;
        }
    }

    status = CTF_METADATA_DECODER_STATUS_NONE;

end:
    g_free(left);
    return status;
}

BT_HIDDEN
enum ctf_metadata_decoder_status
ctf_metadata_decoder_get_trace_class_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
{
    enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
    struct ctf_node *root_node = &mdec->scanner->ast->root;
    struct ctf_node *trace_node;

    if (!root_node) {
        status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
        goto end;
    }

    trace_node = bt_list_entry(root_node->u.root.trace.next, struct ctf_node, siblings);
    if (!trace_node) {
        status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
        goto end;
    }

    status = find_uuid_in_trace_decl(mdec, trace_node, uuid);

end:
    return status;
}
Commit	Line	Data
1e649dff	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
1e649dff	3	*
0235b0db	4	* Copyright 2016-2017 Philippe Proulx <pproulx@efficios.com>
1e649dff PP	5	*/
1e649dff PP	6
4164020e	7	#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
50f6fce8	8	#define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
4164020e SM	9	#define BT_LOG_OUTPUT_LEVEL (mdec->config.log_level)
4164020e SM	10	#define BT_LOG_TAG "PLUGIN/CTF/META/DECODER"
d9c39b0a	11	#include "logging/comp-logging.h"
d6e20753	12
1e649dff PP	13	#include <stdio.h>
	14	#include <stdbool.h>
	15	#include <stdint.h>
	16	#include <stdlib.h>
d6e20753	17	#include <inttypes.h>
578e048b	18	#include "common/assert.h"
6162e6b7	19	#include "common/uuid.h"
578e048b	20	#include "compat/memstream.h"
3fadfbc0	21	#include <babeltrace2/babeltrace.h>
1e649dff	22	#include <glib.h>
e9383dfd	23	#include <string.h>
1e649dff	24
087cd0f5 SM	25	#include "ast.hpp"
	26	#include "decoder.hpp"
	27	#include "scanner.hpp"
	28	#include "logging.hpp"
	29	#include "parser-wrap.hpp"
	30	#include "decoder-packetized-file-stream-to-buf.hpp"
1e649dff	31
4164020e SM	32	#define TSDL_MAGIC 0x75d11d57
	33
	34	struct ctf_metadata_decoder
	35	{
	36	struct ctf_scanner *scanner;
	37	GString *text;
	38	struct ctf_visitor_generate_ir *visitor;
	39	bt_uuid_t uuid;
	40	bool is_uuid_set;
	41	int bo;
	42	struct ctf_metadata_decoder_config config;
	43	struct meta_log_config log_cfg;
a4613497	44	bool has_checked_plaintext_signature;
1e649dff PP	45	};
1e649dff PP	46
4164020e SM	47	struct packet_header
	48	{
	49	uint32_t magic;
	50	bt_uuid_t uuid;
	51	uint32_t checksum;
	52	uint32_t content_size;
	53	uint32_t packet_size;
	54	uint8_t compression_scheme;
	55	uint8_t encryption_scheme;
	56	uint8_t checksum_scheme;
	57	uint8_t major;
	58	uint8_t minor;
1e649dff PP	59	} __attribute__((__packed__));
1e649dff PP	60
06be9946	61	BT_HIDDEN
4164020e SM	62	int ctf_metadata_decoder_is_packetized(FILE fp, bool is_packetized, int *byte_order,
4164020e SM	63	bt_logging_level log_level, bt_self_component *self_comp)
1e649dff	64	{
4164020e SM	65	uint32_t magic;
	66	size_t len;
	67	int ret = 0;
	68
	69	*is_packetized = false;
	70	len = fread(&magic, sizeof(magic), 1, fp);
	71	if (len != 1) {
	72	BT_COMP_LOG_CUR_LVL(
	73	BT_LOG_INFO, log_level, self_comp,
	74	"Cannot read first metadata packet header: assuming the stream is not packetized.");
	75	ret = -1;
	76	goto end;
	77	}
	78
	79	if (byte_order) {
	80	if (magic == TSDL_MAGIC) {
	81	*is_packetized = true;
	82	*byte_order = BYTE_ORDER;
	83	} else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
	84	*is_packetized = true;
	85	*byte_order = BYTE_ORDER == BIG_ENDIAN ? LITTLE_ENDIAN : BIG_ENDIAN;
	86	}
	87	}
1e649dff PP	88
1e649dff PP	89	end:
4164020e	90	rewind(fp);
1e649dff	91
4164020e	92	return ret;
1e649dff PP	93	}
1e649dff PP	94
1e649dff	95	BT_HIDDEN
4164020e SM	96	struct ctf_metadata_decoder *
4164020e SM	97	ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config)
1e649dff	98	{
4164020e SM	99	struct ctf_metadata_decoder *mdec = g_new0(struct ctf_metadata_decoder, 1);
	100
	101	BT_ASSERT(config);
	102	BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
	103	"Creating CTF metadata decoder: "
	104	"clock-class-offset-s=%" PRId64 ", "
	105	"clock-class-offset-ns=%" PRId64,
	106	config->clock_class_offset_s, config->clock_class_offset_ns);
	107
	108	if (!mdec) {
	109	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level, config->self_comp,
	110	"Failed to allocate one CTF metadata decoder.");
	111	goto end;
	112	}
	113
	114	mdec->log_cfg.log_level = config->log_level;
	115	mdec->log_cfg.self_comp = config->self_comp;
	116	mdec->log_cfg.self_comp_class = config->self_comp_class;
	117	mdec->scanner = ctf_scanner_alloc();
	118	if (!mdec->scanner) {
	119	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
	120	"mdec-addr=%p",
	121	mdec);
	122	goto error;
	123	}
	124
	125	mdec->text = g_string_new(NULL);
	126	if (!mdec->text) {
	127	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one GString: "
	128	"mdec-addr=%p",
	129	mdec);
	130	goto error;
	131	}
	132
	133	mdec->bo = -1;
	134	mdec->config = *config;
	135	mdec->visitor = ctf_visitor_generate_ir_create(config);
	136	if (!mdec->visitor) {
	137	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
	138	"mdec-addr=%p",
	139	mdec);
	140	goto error;
	141	}
	142
	143	BT_COMP_LOGD("Creating CTF metadata decoder: "
	144	"clock-class-offset-s=%" PRId64 ", "
	145	"clock-class-offset-ns=%" PRId64 ", addr=%p",
	146	config->clock_class_offset_s, config->clock_class_offset_ns, mdec);
	147	goto end;
06be9946 PP	148
06be9946 PP	149	error:
4164020e SM	150	ctf_metadata_decoder_destroy(mdec);
4164020e SM	151	mdec = NULL;
d6e20753	152
1e649dff	153	end:
4164020e	154	return mdec;
1e649dff PP	155	}
	156
	157	BT_HIDDEN
	158	void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
	159	{
4164020e SM	160	if (!mdec) {
	161	return;
	162	}
1e649dff	163
4164020e SM	164	if (mdec->scanner) {
	165	ctf_scanner_free(mdec->scanner);
	166	}
06be9946	167
4164020e SM	168	if (mdec->text) {
	169	g_string_free(mdec->text, TRUE);
	170	}
06be9946	171
4164020e SM	172	BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
	173	ctf_visitor_generate_ir_destroy(mdec->visitor);
	174	g_free(mdec);
1e649dff PP	175	}
	176
	177	BT_HIDDEN
4164020e SM	178	enum ctf_metadata_decoder_status
4164020e SM	179	ctf_metadata_decoder_append_content(struct ctf_metadata_decoder mdec, FILE fp)
1e649dff	180	{
4164020e SM	181	enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
	182	int ret;
	183	char *buf = NULL;
	184	bool close_fp = false;
	185	long start_pos = -1;
	186	bool is_packetized;
	187
	188	BT_ASSERT(mdec);
	189	ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo, mdec->config.log_level,
	190	mdec->config.self_comp);
	191	if (ret) {
	192	status = CTF_METADATA_DECODER_STATUS_ERROR;
	193	goto end;
	194	}
	195
	196	if (is_packetized) {
	197	BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
	198	ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
	199	fp, &buf, mdec->bo, &mdec->is_uuid_set, mdec->uuid, mdec->config.log_level,
	200	mdec->config.self_comp, mdec->config.self_comp_class);
	201	if (ret) {
	202	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
	203	"Cannot decode packetized metadata packets to metadata text: "
	204	"mdec-addr=%p, ret=%d",
	205	mdec, ret);
	206	status = CTF_METADATA_DECODER_STATUS_ERROR;
	207	goto end;
	208	}
	209
	210	if (strlen(buf) == 0) {
	211	/* An empty metadata packet is OK. */
	212	goto end;
	213	}
	214
	215	/* Convert the real file pointer to a memory file pointer */
	216	fp = bt_fmemopen(buf, strlen(buf), "rb");
	217	close_fp = true;
	218	if (!fp) {
	219	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
	220	"mdec-addr=%p",
	221	strerror(errno), mdec);
	222	status = CTF_METADATA_DECODER_STATUS_ERROR;
	223	goto end;
	224	}
a4613497	225	} else if (!mdec->has_checked_plaintext_signature) {
4164020e SM	226	unsigned int major, minor;
	227	ssize_t nr_items;
	228	const long init_pos = ftell(fp);
	229
	230	BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
	231
	232	if (init_pos < 0) {
	233	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
	234	"Failed to get current file position", ".");
	235	status = CTF_METADATA_DECODER_STATUS_ERROR;
	236	goto end;
	237	}
	238
	239	/* Check text-only metadata header and version */
	240	nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
	241	if (nr_items < 2) {
	242	BT_COMP_LOGW(
	243	"Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
	244	"mdec-addr=%p",
	245	mdec);
	246	}
	247
	248	BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
	249
	250	if (!ctf_metadata_decoder_is_packet_version_valid(major, minor)) {
	251	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
	252	"Invalid metadata version found in plain text signature: "
	253	"version=%u.%u, mdec-addr=%p",
	254	major, minor, mdec);
	255	status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
	256	goto end;
	257	}
	258
	259	if (fseek(fp, init_pos, SEEK_SET)) {
	260	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
	261	"Cannot seek metadata file stream to initial position: %s: "
	262	"mdec-addr=%p",
	263	strerror(errno), mdec);
	264	status = CTF_METADATA_DECODER_STATUS_ERROR;
	265	goto end;
	266	}
a4613497 FD	267
a4613497 FD	268	mdec->has_checked_plaintext_signature = true;
4164020e	269	}
1e649dff	270
9103e903	271	#if YYDEBUG
4164020e SM	272	if (BT_LOG_ON_TRACE) {
	273	yydebug = 1;
	274	}
9103e903	275	#endif
f73367f8	276
4164020e SM	277	/* Save the file's position: we'll seek back to append the plain text */
	278	BT_ASSERT(fp);
	279
	280	if (mdec->config.keep_plain_text) {
	281	start_pos = ftell(fp);
	282	}
	283
	284	/* Append the metadata text content */
	285	ret = ctf_scanner_append_ast(mdec->scanner, fp);
	286	if (ret) {
	287	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
	288	"Cannot create the metadata AST out of the metadata text: "
	289	"mdec-addr=%p",
	290	mdec);
	291	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	292	goto end;
	293	}
	294
	295	/* We know it's complete: append plain text */
	296	if (mdec->config.keep_plain_text) {
	297	BT_ASSERT(start_pos != -1);
	298	ret = fseek(fp, start_pos, SEEK_SET);
	299	if (ret) {
	300	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
	301	ret, mdec);
	302	status = CTF_METADATA_DECODER_STATUS_ERROR;
	303	goto end;
	304	}
	305
	306	ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
	307	if (ret) {
	308	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
	309	"ret=%d, mdec-addr=%p",
	310	ret, mdec);
	311	status = CTF_METADATA_DECODER_STATUS_ERROR;
	312	goto end;
	313	}
	314	}
	315
	316	ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root, &mdec->log_cfg);
	317	if (ret) {
	318	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
	319	"mdec-addr=%p",
	320	mdec);
	321	status = CTF_METADATA_DECODER_STATUS_ERROR;
	322	goto end;
	323	}
	324
	325	if (mdec->config.create_trace_class) {
	326	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor, &mdec->scanner->ast->root);
	327	switch (ret) {
	328	case 0:
	329	/* Success */
	330	break;
	331	case -EINCOMPLETE:
	332	BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
	333	"mdec-addr=%p",
	334	mdec);
	335	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	336	goto end;
	337	default:
	338	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
	339	"Failed to visit AST node to create CTF IR objects: "
	340	"mdec-addr=%p, ret=%d",
341	mdec, ret);
342	status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
343	goto end;
344	}
345	}
1e649dff PP	346
1e649dff PP	347	end:
9103e903	348	#if YYDEBUG
4164020e	349	yydebug = 0;
9103e903	350	#endif
f73367f8	351
4164020e SM	352	if (fp && close_fp) {
	353	if (fclose(fp)) {
	354	BT_COMP_LOGE("Cannot close metadata file stream: "
	355	"mdec-addr=%p",
	356	mdec);
	357	}
	358	}
1e649dff	359
4164020e	360	free(buf);
1e649dff	361
4164020e	362	return status;
1e649dff PP	363	}
	364
	365	BT_HIDDEN
4164020e	366	bt_trace_class ctf_metadata_decoder_get_ir_trace_class(struct ctf_metadata_decoder mdec)
44c440bc	367	{
4164020e SM	368	BT_ASSERT_DBG(mdec);
	369	BT_ASSERT_DBG(mdec->config.create_trace_class);
	370	return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
44c440bc PP	371	}
	372
	373	BT_HIDDEN
4164020e SM	374	struct ctf_trace_class *
4164020e SM	375	ctf_metadata_decoder_borrow_ctf_trace_class(struct ctf_metadata_decoder *mdec)
1e649dff	376	{
4164020e SM	377	BT_ASSERT_DBG(mdec);
	378	BT_ASSERT_DBG(mdec->config.create_trace_class);
	379	return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
1e649dff	380	}
06be9946 PP	381
	382	BT_HIDDEN
	383	const char ctf_metadata_decoder_get_text(struct ctf_metadata_decoder mdec)
	384	{
4164020e SM	385	BT_ASSERT_DBG(mdec);
	386	BT_ASSERT_DBG(mdec->config.keep_plain_text);
	387	return mdec->text->str;
06be9946 PP	388	}
	389
	390	BT_HIDDEN
	391	int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
	392	{
4164020e SM	393	BT_ASSERT_DBG(mdec);
4164020e SM	394	return mdec->bo;
06be9946 PP	395	}
	396
	397	BT_HIDDEN
4164020e	398	int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
06be9946	399	{
4164020e	400	int ret = 0;
06be9946	401
4164020e	402	BT_ASSERT_DBG(mdec);
06be9946	403
4164020e SM	404	if (!mdec->is_uuid_set) {
	405	ret = -1;
	406	goto end;
	407	}
06be9946	408
4164020e	409	bt_uuid_copy(uuid, mdec->uuid);
06be9946 PP	410
06be9946 PP	411	end:
4164020e	412	return ret;
06be9946	413	}
1a6da3f9	414
4164020e SM	415	static enum ctf_metadata_decoder_status find_uuid_in_trace_decl(struct ctf_metadata_decoder *mdec,
	416	struct ctf_node *trace_node,
	417	bt_uuid_t uuid)
1a6da3f9	418	{
4164020e SM	419	enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
	420	struct ctf_node *entry_node;
	421	struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
	422	char *left = NULL;
	423
	424	bt_list_for_each_entry (entry_node, decl_list, siblings) {
	425	if (entry_node->type == NODE_CTF_EXPRESSION) {
	426	int ret;
	427
	428	left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
	429	if (!left) {
	430	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
	431	status = CTF_METADATA_DECODER_STATUS_ERROR;
	432	goto end;
	433	}
	434
	435	if (strcmp(left, "uuid") == 0) {
	436	ret = ctf_ast_get_unary_uuid(&entry_node->u.ctf_expression.right, uuid,
	437	mdec->config.log_level, mdec->config.self_comp);
	438	if (ret) {
	439	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
	440	status = CTF_METADATA_DECODER_STATUS_ERROR;
	441	goto end;
	442	}
	443
	444	goto end;
	445	}
	446
	447	g_free(left);
	448	left = NULL;
	449	}
	450	}
	451
	452	status = CTF_METADATA_DECODER_STATUS_NONE;
1a6da3f9 PP	453
1a6da3f9 PP	454	end:
4164020e SM	455	g_free(left);
4164020e SM	456	return status;
1a6da3f9 PP	457	}
	458
	459	BT_HIDDEN
4164020e SM	460	enum ctf_metadata_decoder_status
4164020e SM	461	ctf_metadata_decoder_get_trace_class_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
1a6da3f9	462	{
4164020e SM	463	enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	464	struct ctf_node *root_node = &mdec->scanner->ast->root;
	465	struct ctf_node *trace_node;
	466
	467	if (!root_node) {
	468	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	469	goto end;
	470	}
	471
	472	trace_node = bt_list_entry(root_node->u.root.trace.next, struct ctf_node, siblings);
	473	if (!trace_node) {
	474	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	475	goto end;
	476	}
	477
	478	status = find_uuid_in_trace_decl(mdec, trace_node, uuid);
1a6da3f9 PP	479
1a6da3f9 PP	480	end:
4164020e	481	return status;
1a6da3f9	482	}