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

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

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include "common/assert.h"
#include "common/uuid.h"
#include "compat/memstream.h"
#include "cpp-common/vendor/fmt/format.h"

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

#define TSDL_MAGIC 0x75d11d57

struct ctf_metadata_decoder
{
    explicit ctf_metadata_decoder(const bt2c::Logger& parentLogger) :
        logger {parentLogger, "PLUGIN/CTF/META/DECODER"}, config {logger}
    {
    }

    bt2c::Logger logger;
    struct ctf_scanner *scanner = nullptr;
    GString *text = nullptr;
    ctf_visitor_generate_ir::UP visitor;
    bt_uuid_t uuid {};
    bool is_uuid_set = false;
    int bo = 0;
    struct ctf_metadata_decoder_config config;
    bool has_checked_plaintext_signature = false;
};

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__));

int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized, int *byte_order,
                                       const bt2c::Logger& logger)
{
    uint32_t magic;
    size_t len;
    int ret = 0;

    *is_packetized = false;
    len = fread(&magic, sizeof(magic), 1, fp);
    if (len != 1) {
        BT_CPPLOGI_SPEC(
            logger,
            "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;
}

ctf_metadata_decoder_up
ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config)
{
    BT_ASSERT(config);

    BT_CPPLOGD_SPEC(config->logger,
                    "Creating CTF metadata decoder: "
                    "clock-class-offset-s={}, "
                    "clock-class-offset-ns={}",
                    config->clock_class_offset_s, config->clock_class_offset_ns);

    ctf_metadata_decoder *mdec = new ctf_metadata_decoder {config->logger};
    mdec->scanner = ctf_scanner_alloc(mdec->logger);
    if (!mdec->scanner) {
        BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                     "Cannot allocate a metadata lexical scanner: "
                                     "mdec-addr={}",
                                     fmt::ptr(mdec));
        goto error;
    }

    mdec->text = g_string_new(NULL);
    if (!mdec->text) {
        BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                     "Failed to allocate one GString: "
                                     "mdec-addr={}",
                                     fmt::ptr(mdec));
        goto error;
    }

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

    BT_CPPLOGD_SPEC(mdec->logger,
                    "Creating CTF metadata decoder: "
                    "clock-class-offset-s={}, "
                    "clock-class-offset-ns={}, addr={}",
                    config->clock_class_offset_s, config->clock_class_offset_ns, fmt::ptr(mdec));
    goto end;

error:
    ctf_metadata_decoder_destroy(mdec);
    mdec = NULL;

end:
    return ctf_metadata_decoder_up {mdec};
}

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_CPPLOGD_SPEC(mdec->logger, "Destroying CTF metadata decoder: addr={}", fmt::ptr(mdec));

    delete mdec;
}

void ctf_metadata_decoder_deleter::operator()(ctf_metadata_decoder *decoder)
{
    ctf_metadata_decoder_destroy(decoder);
}

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->logger);
    if (ret) {
        status = CTF_METADATA_DECODER_STATUS_ERROR;
        goto end;
    }

    if (is_packetized) {
        BT_CPPLOGI_SPEC(mdec->logger, "Metadata stream is packetized: mdec-addr={}",
                        fmt::ptr(mdec));
        ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
            fp, &buf, mdec->bo, &mdec->is_uuid_set, mdec->uuid, mdec->logger);
        if (ret) {
            BT_CPPLOGE_APPEND_CAUSE_SPEC(
                mdec->logger,
                "Cannot decode packetized metadata packets to metadata text: "
                "mdec-addr={}, ret={}",
                fmt::ptr(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_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                         "Cannot memory-open metadata buffer: {}: "
                                         "mdec-addr={}",
                                         strerror(errno), fmt::ptr(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_CPPLOGI_SPEC(mdec->logger, "Metadata stream is plain text: mdec-addr={}",
                        fmt::ptr(mdec));

        if (init_pos < 0) {
            BT_CPPLOGE_ERRNO_APPEND_CAUSE_SPEC(mdec->logger, "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_CPPLOGW_SPEC(
                mdec->logger,
                "Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
                "mdec-addr={}",
                fmt::ptr(mdec));
        }

        BT_CPPLOGI_SPEC(mdec->logger, "Found metadata stream version in signature: version={}.{}",
                        major, minor);

        if (!ctf_metadata_decoder_is_packet_version_valid(major, minor)) {
            BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                         "Invalid metadata version found in plain text signature: "
                                         "version={}.{}, mdec-addr={}",
                                         major, minor, fmt::ptr(mdec));
            status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
            goto end;
        }

        if (fseek(fp, init_pos, SEEK_SET)) {
            BT_CPPLOGE_APPEND_CAUSE_SPEC(
                mdec->logger,
                "Cannot seek metadata file stream to initial position: {}: "
                "mdec-addr={}",
                strerror(errno), fmt::ptr(mdec));
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        mdec->has_checked_plaintext_signature = true;
    }

#if YYDEBUG
    if (mdec->logger.wouldLogT()) {
        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_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                     "Cannot create the metadata AST out of the metadata text: "
                                     "mdec-addr={}",
                                     fmt::ptr(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_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger, "Failed to seek file: ret={}, mdec-addr={}",
                                         ret, fmt::ptr(mdec));
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }

        ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
        if (ret) {
            BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                         "Failed to append to current plain text: "
                                         "ret={}, mdec-addr={}",
                                         ret, fmt::ptr(mdec));
            status = CTF_METADATA_DECODER_STATUS_ERROR;
            goto end;
        }
    }

    ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root, mdec->logger);
    if (ret) {
        BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                     "Validation of the metadata semantics failed: "
                                     "mdec-addr={}",
                                     fmt::ptr(mdec));
        status = CTF_METADATA_DECODER_STATUS_ERROR;
        goto end;
    }

    if (mdec->config.create_trace_class) {
        ret = ctf_visitor_generate_ir_visit_node(mdec->visitor.get(), &mdec->scanner->ast->root);
        switch (ret) {
        case 0:
            /* Success */
            break;
        case -EINCOMPLETE:
            BT_CPPLOGD_SPEC(mdec->logger,
                            "While visiting metadata AST: incomplete data: "
                            "mdec-addr={}",
                            fmt::ptr(mdec));
            status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
            goto end;
        default:
            BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger,
                                         "Failed to visit AST node to create CTF IR objects: "
                                         "mdec-addr={}, ret={}",
                                         fmt::ptr(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_CPPLOGE_SPEC(mdec->logger,
                            "Cannot close metadata file stream: "
                            "mdec-addr={}",
                            fmt::ptr(mdec));
        }
    }

    free(buf);

    return status;
}

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.get());
}

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.get());
}

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;
}

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

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_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger, "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->logger);
                if (ret) {
                    BT_CPPLOGE_APPEND_CAUSE_SPEC(mdec->logger, "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;
}

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