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

/*
 * Copyright 2016-2017 - Philippe Proulx <pproulx@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

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

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

#include "ast.h"
#include "decoder.h"
#include "scanner.h"
#include "logging.h"

#define TSDL_MAGIC	0x75d11d57

extern
int yydebug;

struct ctf_metadata_decoder {
	struct ctf_visitor_generate_ir *visitor;
	uint8_t uuid[16];
	bool is_uuid_set;
	int bo;
	struct ctf_metadata_decoder_config config;
};

struct packet_header {
	uint32_t magic;
	uint8_t  uuid[16];
	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
bool ctf_metadata_decoder_is_packetized(FILE *fp, int *byte_order,
		bt_logging_level log_level, bt_self_component *self_comp)
{
	uint32_t magic;
	size_t len;
	int ret = 0;

	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.");
		goto end;
	}

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

end:
	rewind(fp);

	return ret;
}

static
bool is_version_valid(unsigned int major, unsigned int minor)
{
	return major == 1 && minor == 8;
}

static
int decode_packet(struct ctf_metadata_decoder *mdec, FILE *in_fp, FILE *out_fp,
		int byte_order)
{
	struct packet_header header;
	size_t readlen, writelen, toread;
	uint8_t buf[512 + 1];	/* + 1 for debug-mode \0 */
	int ret = 0;
	const long offset = ftell(in_fp);

	if (offset < 0) {
		BT_COMP_LOGE_ERRNO("Failed to get current metadata file position",
			".");
		goto error;
	}
	BT_COMP_LOGD("Decoding metadata packet: mdec-addr=%p, offset=%ld",
		mdec, offset);
	readlen = fread(&header, sizeof(header), 1, in_fp);
	if (feof(in_fp) != 0) {
		BT_COMP_LOGI("Reached end of file: offset=%ld", ftell(in_fp));
		goto end;
	}
	if (readlen < 1) {
		BT_COMP_LOGE("Cannot decode metadata packet: offset=%ld", offset);
		goto error;
	}

	if (byte_order != BYTE_ORDER) {
		header.magic = GUINT32_SWAP_LE_BE(header.magic);
		header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
		header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
		header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
	}

	if (header.compression_scheme) {
		BT_COMP_LOGE("Metadata packet compression is not supported as of this version: "
			"compression-scheme=%u, offset=%ld",
			(unsigned int) header.compression_scheme, offset);
		goto error;
	}

	if (header.encryption_scheme) {
		BT_COMP_LOGE("Metadata packet encryption is not supported as of this version: "
			"encryption-scheme=%u, offset=%ld",
			(unsigned int) header.encryption_scheme, offset);
		goto error;
	}

	if (header.checksum || header.checksum_scheme) {
		BT_COMP_LOGE("Metadata packet checksum verification is not supported as of this version: "
			"checksum-scheme=%u, checksum=%x, offset=%ld",
			(unsigned int) header.checksum_scheme, header.checksum,
			offset);
		goto error;
	}

	if (!is_version_valid(header.major, header.minor)) {
		BT_COMP_LOGE("Invalid metadata packet version: "
			"version=%u.%u, offset=%ld",
			header.major, header.minor, offset);
		goto error;
	}

	/* Set expected trace UUID if not set; otherwise validate it */
	if (mdec) {
		if (!mdec->is_uuid_set) {
			memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
			mdec->is_uuid_set = true;
		} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
			BT_COMP_LOGE("Metadata UUID mismatch between packets of the same stream: "
				"packet-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
				"expected-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
				"offset=%ld",
				(unsigned int) header.uuid[0],
				(unsigned int) header.uuid[1],
				(unsigned int) header.uuid[2],
				(unsigned int) header.uuid[3],
				(unsigned int) header.uuid[4],
				(unsigned int) header.uuid[5],
				(unsigned int) header.uuid[6],
				(unsigned int) header.uuid[7],
				(unsigned int) header.uuid[8],
				(unsigned int) header.uuid[9],
				(unsigned int) header.uuid[10],
				(unsigned int) header.uuid[11],
				(unsigned int) header.uuid[12],
				(unsigned int) header.uuid[13],
				(unsigned int) header.uuid[14],
				(unsigned int) header.uuid[15],
				(unsigned int) mdec->uuid[0],
				(unsigned int) mdec->uuid[1],
				(unsigned int) mdec->uuid[2],
				(unsigned int) mdec->uuid[3],
				(unsigned int) mdec->uuid[4],
				(unsigned int) mdec->uuid[5],
				(unsigned int) mdec->uuid[6],
				(unsigned int) mdec->uuid[7],
				(unsigned int) mdec->uuid[8],
				(unsigned int) mdec->uuid[9],
				(unsigned int) mdec->uuid[10],
				(unsigned int) mdec->uuid[11],
				(unsigned int) mdec->uuid[12],
				(unsigned int) mdec->uuid[13],
				(unsigned int) mdec->uuid[14],
				(unsigned int) mdec->uuid[15],
				offset);
			goto error;
		}
	}

	if ((header.content_size / CHAR_BIT) < sizeof(header)) {
		BT_COMP_LOGE("Bad metadata packet content size: content-size=%u, "
			"offset=%ld", header.content_size, offset);
		goto error;
	}

	toread = header.content_size / CHAR_BIT - sizeof(header);

	for (;;) {
		size_t loop_read;

		loop_read = MIN(sizeof(buf) - 1, toread);
		readlen = fread(buf, sizeof(uint8_t), loop_read, in_fp);
		if (ferror(in_fp)) {
			BT_COMP_LOGE("Cannot read metadata packet buffer: "
				"offset=%ld, read-size=%zu",
				ftell(in_fp), loop_read);
			goto error;
		}
		if (readlen > loop_read) {
			BT_COMP_LOGE("fread returned more byte than expected: "
				"read-size-asked=%zu, read-size-returned=%zu",
				loop_read, readlen);
			goto error;
		}

		writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
		if (writelen < readlen || ferror(out_fp)) {
			BT_COMP_LOGE("Cannot write decoded metadata text to buffer: "
				"read-offset=%ld, write-size=%zu",
				ftell(in_fp), readlen);
			goto error;
		}

		toread -= readlen;
		if (toread == 0) {
			int fseek_ret;

			/* Read leftover padding */
			toread = (header.packet_size - header.content_size) /
				CHAR_BIT;
			fseek_ret = fseek(in_fp, toread, SEEK_CUR);
			if (fseek_ret < 0) {
				BT_COMP_LOGW_STR("Missing padding at the end of the metadata stream.");
			}
			break;
		}
	}

	goto end;

error:
	ret = -1;

end:
	return ret;
}

static
int ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
		struct ctf_metadata_decoder *mdec, FILE *fp,
		char **buf, int byte_order, bt_logging_level log_level,
		bt_self_component *self_comp)
{
	FILE *out_fp;
	size_t size;
	int ret = 0;
	int tret;
	size_t packet_index = 0;

	out_fp = bt_open_memstream(buf, &size);
	if (out_fp == NULL) {
		BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
			"Cannot open memory stream: %s: mdec-addr=%p",
			strerror(errno), mdec);
		goto error;
	}

	for (;;) {
		if (feof(fp) != 0) {
			break;
		}

		tret = decode_packet(mdec, fp, out_fp, byte_order);
		if (tret) {
			BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
				"Cannot decode packet: index=%zu, mdec-addr=%p",
				packet_index, mdec);
			goto error;
		}

		packet_index++;
	}

	/* Make sure the whole string ends with a null character */
	tret = fputc('\0', out_fp);
	if (tret == EOF) {
		BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
			"Cannot append '\\0' to the decoded metadata buffer: "
			"mdec-addr=%p", mdec);
		goto error;
	}

	/* Close stream, which also flushes the buffer */
	ret = bt_close_memstream(buf, &size, out_fp);
	/*
	 * See fclose(3). Further access to out_fp after both success
	 * and error, even through another bt_close_memstream(), results
	 * in undefined behavior. Nullify out_fp to ensure we don't
	 * fclose it twice on error.
	 */
	out_fp = NULL;
	if (ret < 0) {
		BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
			"Cannot close memory stream", ": mdec-addr=%p", mdec);
		goto error;
	}

	goto end;

error:
	ret = -1;

	if (out_fp) {
		if (bt_close_memstream(buf, &size, out_fp)) {
			BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level,
				self_comp, "Cannot close memory stream",
				": mdec-addr=%p", mdec);
		}
	}

	if (*buf) {
		free(*buf);
		*buf = NULL;
	}

end:
	return ret;
}

BT_HIDDEN
int ctf_metadata_decoder_packetized_file_stream_to_buf(
		FILE *fp, char **buf, int byte_order,
		bt_logging_level log_level,
		bt_self_component *self_comp)
{
	return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
		NULL, fp, buf, byte_order, log_level, self_comp);
}

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->config = *config;
	mdec->visitor = ctf_visitor_generate_ir_create(config);
	if (!mdec->visitor) {
		BT_COMP_LOGE("Failed to create a CTF IR metadata AST visitor: "
			"mdec-addr=%p", mdec);
		ctf_metadata_decoder_destroy(mdec);
		mdec = NULL;
		goto end;
	}

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

end:
	return mdec;
}

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

	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_decode(
		struct ctf_metadata_decoder *mdec, FILE *fp)
{
	enum ctf_metadata_decoder_status status =
		CTF_METADATA_DECODER_STATUS_OK;
	int ret;
	struct ctf_scanner *scanner = NULL;
	char *buf = NULL;
	bool close_fp = false;
	struct meta_log_config log_cfg;

	BT_ASSERT(mdec);
	log_cfg.log_level = mdec->config.log_level;
	log_cfg.self_comp = mdec->config.self_comp;

	if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo,
			mdec->config.log_level, mdec->config.self_comp)) {
		BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
			mdec, fp, &buf, mdec->bo, mdec->config.log_level,
			mdec->config.self_comp);
		if (ret) {
			BT_COMP_LOGE("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_LOGE("Cannot memory-open metadata buffer: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	} else {
		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_ERRNO("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 (!is_version_valid(major, minor)) {
			BT_COMP_LOGE("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_LOGE("Cannot seek metadata file stream to initial position: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	}

	if (BT_LOG_ON_TRACE) {
		yydebug = 1;
	}

	/* Allocate a scanner and append the metadata text content */
	scanner = ctf_scanner_alloc();
	if (!scanner) {
		BT_COMP_LOGE("Cannot allocate a metadata lexical scanner: "
			"mdec-addr=%p", mdec);
		status = CTF_METADATA_DECODER_STATUS_ERROR;
		goto end;
	}

	BT_ASSERT(fp);
	ret = ctf_scanner_append_ast(scanner, fp);
	if (ret) {
		BT_COMP_LOGE("Cannot create the metadata AST out of the metadata text: "
			"mdec-addr=%p", mdec);
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	}

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

	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
		&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_LOGE("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 (scanner) {
		ctf_scanner_free(scanner);
	}

	yydebug = 0;

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

	if (buf) {
		free(buf);
	}

	return status;
}

BT_HIDDEN
bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(
		struct ctf_metadata_decoder *mdec)
{
	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)
{
	return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
}
Commit	Line	Data
1e649dff PP	1	/*
	2	* Copyright 2016-2017 - Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*/
	14
f7b785ac	15	#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
0746848c	16	#define BT_LOG_OUTPUT_LEVEL (mdec->config.log_level)
350ad6c1	17	#define BT_LOG_TAG "PLUGIN/CTF/META/DECODER"
f7b785ac	18	#include "plugins/comp-logging.h"
d6e20753	19
1e649dff PP	20	#include <stdio.h>
	21	#include <stdbool.h>
	22	#include <stdint.h>
	23	#include <stdlib.h>
d6e20753	24	#include <inttypes.h>
578e048b MJ	25	#include "common/assert.h"
	26	#include "compat/uuid.h"
	27	#include "compat/memstream.h"
3fadfbc0	28	#include <babeltrace2/babeltrace.h>
1e649dff	29	#include <glib.h>
e9383dfd	30	#include <string.h>
1e649dff PP	31
	32	#include "ast.h"
	33	#include "decoder.h"
	34	#include "scanner.h"
f7b785ac	35	#include "logging.h"
1e649dff	36
1e649dff PP	37	#define TSDL_MAGIC 0x75d11d57
1e649dff PP	38
61d6f9b1	39	extern
f73367f8 PP	40	int yydebug;
f73367f8 PP	41
1e649dff PP	42	struct ctf_metadata_decoder {
1e649dff PP	43	struct ctf_visitor_generate_ir *visitor;
1e649dff PP	44	uint8_t uuid[16];
	45	bool is_uuid_set;
	46	int bo;
a2a54545	47	struct ctf_metadata_decoder_config config;
1e649dff PP	48	};
	49
	50	struct packet_header {
	51	uint32_t magic;
	52	uint8_t uuid[16];
	53	uint32_t checksum;
	54	uint32_t content_size;
	55	uint32_t packet_size;
	56	uint8_t compression_scheme;
	57	uint8_t encryption_scheme;
	58	uint8_t checksum_scheme;
	59	uint8_t major;
	60	uint8_t minor;
	61	} __attribute__((__packed__));
	62
	63	BT_HIDDEN
0746848c	64	bool ctf_metadata_decoder_is_packetized(FILE fp, int byte_order,
f7b785ac	65	bt_logging_level log_level, bt_self_component *self_comp)
1e649dff PP	66	{
	67	uint32_t magic;
	68	size_t len;
	69	int ret = 0;
	70
	71	len = fread(&magic, sizeof(magic), 1, fp);
	72	if (len != 1) {
f7b785ac	73	BT_COMP_LOG_CUR_LVL(BT_LOG_INFO, log_level, self_comp,
0746848c	74	"Cannot read first metadata packet header: assuming the stream is not packetized.");
1e649dff PP	75	goto end;
	76	}
	77
	78	if (byte_order) {
	79	if (magic == TSDL_MAGIC) {
	80	ret = 1;
	81	*byte_order = BYTE_ORDER;
	82	} else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
	83	ret = 1;
	84	*byte_order = BYTE_ORDER == BIG_ENDIAN ?
	85	LITTLE_ENDIAN : BIG_ENDIAN;
	86	}
	87	}
	88
	89	end:
	90	rewind(fp);
	91
	92	return ret;
	93	}
	94
	95	static
	96	bool is_version_valid(unsigned int major, unsigned int minor)
	97	{
	98	return major == 1 && minor == 8;
	99	}
	100
	101	static
	102	int decode_packet(struct ctf_metadata_decoder mdec, FILE in_fp, FILE *out_fp,
	103	int byte_order)
	104	{
	105	struct packet_header header;
	106	size_t readlen, writelen, toread;
	107	uint8_t buf[512 + 1]; /* + 1 for debug-mode \0 */
	108	int ret = 0;
d6e20753	109	const long offset = ftell(in_fp);
1e649dff	110
9e254855	111	if (offset < 0) {
f7b785ac	112	BT_COMP_LOGE_ERRNO("Failed to get current metadata file position",
9e254855 MD	113	".");
	114	goto error;
	115	}
f7b785ac	116	BT_COMP_LOGD("Decoding metadata packet: mdec-addr=%p, offset=%ld",
d6e20753	117	mdec, offset);
1e649dff PP	118	readlen = fread(&header, sizeof(header), 1, in_fp);
1e649dff PP	119	if (feof(in_fp) != 0) {
f7b785ac	120	BT_COMP_LOGI("Reached end of file: offset=%ld", ftell(in_fp));
1e649dff PP	121	goto end;
	122	}
	123	if (readlen < 1) {
f7b785ac	124	BT_COMP_LOGE("Cannot decode metadata packet: offset=%ld", offset);
1e649dff PP	125	goto error;
	126	}
	127
	128	if (byte_order != BYTE_ORDER) {
	129	header.magic = GUINT32_SWAP_LE_BE(header.magic);
	130	header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
	131	header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
	132	header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
	133	}
	134
	135	if (header.compression_scheme) {
f7b785ac	136	BT_COMP_LOGE("Metadata packet compression is not supported as of this version: "
d6e20753 PP	137	"compression-scheme=%u, offset=%ld",
d6e20753 PP	138	(unsigned int) header.compression_scheme, offset);
1e649dff PP	139	goto error;
	140	}
	141
	142	if (header.encryption_scheme) {
f7b785ac	143	BT_COMP_LOGE("Metadata packet encryption is not supported as of this version: "
d6e20753 PP	144	"encryption-scheme=%u, offset=%ld",
d6e20753 PP	145	(unsigned int) header.encryption_scheme, offset);
1e649dff PP	146	goto error;
	147	}
	148
	149	if (header.checksum \|\| header.checksum_scheme) {
f7b785ac	150	BT_COMP_LOGE("Metadata packet checksum verification is not supported as of this version: "
d6e20753 PP	151	"checksum-scheme=%u, checksum=%x, offset=%ld",
	152	(unsigned int) header.checksum_scheme, header.checksum,
	153	offset);
1e649dff PP	154	goto error;
	155	}
	156
	157	if (!is_version_valid(header.major, header.minor)) {
f7b785ac	158	BT_COMP_LOGE("Invalid metadata packet version: "
d6e20753 PP	159	"version=%u.%u, offset=%ld",
d6e20753 PP	160	header.major, header.minor, offset);
1e649dff PP	161	goto error;
	162	}
	163
	164	/* Set expected trace UUID if not set; otherwise validate it */
	165	if (mdec) {
	166	if (!mdec->is_uuid_set) {
	167	memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
	168	mdec->is_uuid_set = true;
	169	} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
f7b785ac	170	BT_COMP_LOGE("Metadata UUID mismatch between packets of the same stream: "
d6e20753 PP	171	"packet-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
	172	"expected-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
	173	"offset=%ld",
	174	(unsigned int) header.uuid[0],
	175	(unsigned int) header.uuid[1],
	176	(unsigned int) header.uuid[2],
	177	(unsigned int) header.uuid[3],
	178	(unsigned int) header.uuid[4],
	179	(unsigned int) header.uuid[5],
	180	(unsigned int) header.uuid[6],
	181	(unsigned int) header.uuid[7],
	182	(unsigned int) header.uuid[8],
	183	(unsigned int) header.uuid[9],
	184	(unsigned int) header.uuid[10],
	185	(unsigned int) header.uuid[11],
	186	(unsigned int) header.uuid[12],
	187	(unsigned int) header.uuid[13],
	188	(unsigned int) header.uuid[14],
	189	(unsigned int) header.uuid[15],
	190	(unsigned int) mdec->uuid[0],
	191	(unsigned int) mdec->uuid[1],
	192	(unsigned int) mdec->uuid[2],
	193	(unsigned int) mdec->uuid[3],
	194	(unsigned int) mdec->uuid[4],
	195	(unsigned int) mdec->uuid[5],
	196	(unsigned int) mdec->uuid[6],
	197	(unsigned int) mdec->uuid[7],
	198	(unsigned int) mdec->uuid[8],
	199	(unsigned int) mdec->uuid[9],
	200	(unsigned int) mdec->uuid[10],
	201	(unsigned int) mdec->uuid[11],
	202	(unsigned int) mdec->uuid[12],
	203	(unsigned int) mdec->uuid[13],
	204	(unsigned int) mdec->uuid[14],
	205	(unsigned int) mdec->uuid[15],
	206	offset);
1e649dff PP	207	goto error;
	208	}
	209	}
	210
	211	if ((header.content_size / CHAR_BIT) < sizeof(header)) {
f7b785ac	212	BT_COMP_LOGE("Bad metadata packet content size: content-size=%u, "
d6e20753	213	"offset=%ld", header.content_size, offset);
1e649dff PP	214	goto error;
	215	}
	216
	217	toread = header.content_size / CHAR_BIT - sizeof(header);
	218
	219	for (;;) {
9e254855 MD	220	size_t loop_read;
	221
	222	loop_read = MIN(sizeof(buf) - 1, toread);
	223	readlen = fread(buf, sizeof(uint8_t), loop_read, in_fp);
1e649dff	224	if (ferror(in_fp)) {
f7b785ac	225	BT_COMP_LOGE("Cannot read metadata packet buffer: "
9e254855 MD	226	"offset=%ld, read-size=%zu",
	227	ftell(in_fp), loop_read);
	228	goto error;
	229	}
	230	if (readlen > loop_read) {
f7b785ac	231	BT_COMP_LOGE("fread returned more byte than expected: "
9e254855 MD	232	"read-size-asked=%zu, read-size-returned=%zu",
9e254855 MD	233	loop_read, readlen);
1e649dff PP	234	goto error;
	235	}
	236
	237	writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
	238	if (writelen < readlen \|\| ferror(out_fp)) {
f7b785ac	239	BT_COMP_LOGE("Cannot write decoded metadata text to buffer: "
9e254855 MD	240	"read-offset=%ld, write-size=%zu",
9e254855 MD	241	ftell(in_fp), readlen);
1e649dff PP	242	goto error;
	243	}
	244
	245	toread -= readlen;
	246	if (toread == 0) {
	247	int fseek_ret;
	248
	249	/* Read leftover padding */
	250	toread = (header.packet_size - header.content_size) /
	251	CHAR_BIT;
	252	fseek_ret = fseek(in_fp, toread, SEEK_CUR);
	253	if (fseek_ret < 0) {
f7b785ac	254	BT_COMP_LOGW_STR("Missing padding at the end of the metadata stream.");
1e649dff	255	}
1e649dff PP	256	break;
	257	}
	258	}
	259
	260	goto end;
	261
	262	error:
	263	ret = -1;
	264
	265	end:
	266	return ret;
	267	}
	268
	269	static
	270	int ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
	271	struct ctf_metadata_decoder mdec, FILE fp,
f7b785ac PP	272	char **buf, int byte_order, bt_logging_level log_level,
f7b785ac PP	273	bt_self_component *self_comp)
1e649dff PP	274	{
	275	FILE *out_fp;
	276	size_t size;
	277	int ret = 0;
	278	int tret;
	279	size_t packet_index = 0;
	280
	281	out_fp = bt_open_memstream(buf, &size);
	282	if (out_fp == NULL) {
f7b785ac	283	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
0746848c	284	"Cannot open memory stream: %s: mdec-addr=%p",
d6e20753	285	strerror(errno), mdec);
1e649dff PP	286	goto error;
	287	}
	288
	289	for (;;) {
	290	if (feof(fp) != 0) {
	291	break;
	292	}
	293
	294	tret = decode_packet(mdec, fp, out_fp, byte_order);
	295	if (tret) {
f7b785ac	296	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
0746848c	297	"Cannot decode packet: index=%zu, mdec-addr=%p",
d6e20753	298	packet_index, mdec);
1e649dff PP	299	goto error;
	300	}
	301
	302	packet_index++;
	303	}
	304
	305	/* Make sure the whole string ends with a null character */
	306	tret = fputc('\0', out_fp);
	307	if (tret == EOF) {
f7b785ac	308	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
0746848c	309	"Cannot append '\\0' to the decoded metadata buffer: "
d6e20753	310	"mdec-addr=%p", mdec);
1e649dff PP	311	goto error;
	312	}
	313
	314	/* Close stream, which also flushes the buffer */
	315	ret = bt_close_memstream(buf, &size, out_fp);
47eba00a MD	316	/*
	317	* See fclose(3). Further access to out_fp after both success
	318	* and error, even through another bt_close_memstream(), results
	319	* in undefined behavior. Nullify out_fp to ensure we don't
	320	* fclose it twice on error.
	321	*/
	322	out_fp = NULL;
1e649dff	323	if (ret < 0) {
f7b785ac	324	BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
0746848c	325	"Cannot close memory stream", ": mdec-addr=%p", mdec);
1e649dff PP	326	goto error;
	327	}
	328
	329	goto end;
	330
	331	error:
	332	ret = -1;
	333
	334	if (out_fp) {
d6e20753	335	if (bt_close_memstream(buf, &size, out_fp)) {
f7b785ac PP	336	BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level,
	337	self_comp, "Cannot close memory stream",
	338	": mdec-addr=%p", mdec);
d6e20753	339	}
1e649dff PP	340	}
	341
	342	if (*buf) {
	343	free(*buf);
8318bbaa	344	*buf = NULL;
1e649dff PP	345	}
	346
	347	end:
	348	return ret;
	349	}
	350
	351	BT_HIDDEN
	352	int ctf_metadata_decoder_packetized_file_stream_to_buf(
0746848c	353	FILE fp, char *buf, int byte_order,
f7b785ac PP	354	bt_logging_level log_level,
f7b785ac PP	355	bt_self_component *self_comp)
1e649dff PP	356	{
1e649dff PP	357	return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
f7b785ac	358	NULL, fp, buf, byte_order, log_level, self_comp);
1e649dff PP	359	}
	360
	361	BT_HIDDEN
55314f2a	362	struct ctf_metadata_decoder *ctf_metadata_decoder_create(
862ca4ed	363	const struct ctf_metadata_decoder_config *config)
1e649dff PP	364	{
	365	struct ctf_metadata_decoder *mdec =
	366	g_new0(struct ctf_metadata_decoder, 1);
a2a54545	367
f7b785ac PP	368	BT_ASSERT(config);
	369	BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
	370	"Creating CTF metadata decoder: "
a2a54545	371	"clock-class-offset-s=%" PRId64 ", "
862ca4ed PP	372	"clock-class-offset-ns=%" PRId64,
862ca4ed PP	373	config->clock_class_offset_s, config->clock_class_offset_ns);
d6e20753	374
1e649dff	375	if (!mdec) {
f7b785ac PP	376	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level,
	377	config->self_comp,
	378	"Failed to allocate one CTF metadata decoder.");
1e649dff PP	379	goto end;
	380	}
	381
a2a54545	382	mdec->config = *config;
f7b785ac	383	mdec->visitor = ctf_visitor_generate_ir_create(config);
1e649dff	384	if (!mdec->visitor) {
f7b785ac	385	BT_COMP_LOGE("Failed to create a CTF IR metadata AST visitor: "
d6e20753	386	"mdec-addr=%p", mdec);
1e649dff PP	387	ctf_metadata_decoder_destroy(mdec);
	388	mdec = NULL;
	389	goto end;
	390	}
	391
f7b785ac	392	BT_COMP_LOGD("Creating CTF metadata decoder: "
a2a54545	393	"clock-class-offset-s=%" PRId64 ", "
862ca4ed	394	"clock-class-offset-ns=%" PRId64 ", addr=%p",
a2a54545	395	config->clock_class_offset_s, config->clock_class_offset_ns,
862ca4ed	396	mdec);
d6e20753	397
1e649dff PP	398	end:
	399	return mdec;
	400	}
	401
	402	BT_HIDDEN
	403	void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
	404	{
	405	if (!mdec) {
	406	return;
	407	}
	408
f7b785ac	409	BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
1e649dff PP	410	ctf_visitor_generate_ir_destroy(mdec->visitor);
	411	g_free(mdec);
	412	}
	413
	414	BT_HIDDEN
	415	enum ctf_metadata_decoder_status ctf_metadata_decoder_decode(
	416	struct ctf_metadata_decoder mdec, FILE fp)
	417	{
	418	enum ctf_metadata_decoder_status status =
	419	CTF_METADATA_DECODER_STATUS_OK;
	420	int ret;
	421	struct ctf_scanner *scanner = NULL;
	422	char *buf = NULL;
	423	bool close_fp = false;
f7b785ac	424	struct meta_log_config log_cfg;
1e649dff	425
f6ccaed9	426	BT_ASSERT(mdec);
f7b785ac PP	427	log_cfg.log_level = mdec->config.log_level;
f7b785ac PP	428	log_cfg.self_comp = mdec->config.self_comp;
1e649dff	429
0746848c	430	if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo,
f7b785ac PP	431	mdec->config.log_level, mdec->config.self_comp)) {
f7b785ac PP	432	BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
1e649dff	433	ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
f7b785ac PP	434	mdec, fp, &buf, mdec->bo, mdec->config.log_level,
f7b785ac PP	435	mdec->config.self_comp);
1e649dff	436	if (ret) {
f7b785ac	437	BT_COMP_LOGE("Cannot decode packetized metadata packets to metadata text: "
d6e20753	438	"mdec-addr=%p, ret=%d", mdec, ret);
1e649dff PP	439	status = CTF_METADATA_DECODER_STATUS_ERROR;
	440	goto end;
	441	}
	442
7cdc2bab MD	443	if (strlen(buf) == 0) {
	444	/* An empty metadata packet is OK. */
	445	goto end;
	446	}
	447
1e649dff PP	448	/* Convert the real file pointer to a memory file pointer */
	449	fp = bt_fmemopen(buf, strlen(buf), "rb");
	450	close_fp = true;
	451	if (!fp) {
f7b785ac	452	BT_COMP_LOGE("Cannot memory-open metadata buffer: %s: "
d6e20753	453	"mdec-addr=%p", strerror(errno), mdec);
1e649dff PP	454	status = CTF_METADATA_DECODER_STATUS_ERROR;
	455	goto end;
	456	}
	457	} else {
	458	unsigned int major, minor;
	459	ssize_t nr_items;
	460	const long init_pos = ftell(fp);
	461
f7b785ac	462	BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
1e649dff	463
1e95e5e8	464	if (init_pos < 0) {
f7b785ac	465	BT_COMP_LOGE_ERRNO("Failed to get current file position", ".");
1e95e5e8 MD	466	status = CTF_METADATA_DECODER_STATUS_ERROR;
	467	goto end;
	468	}
	469
1e649dff PP	470	/* Check text-only metadata header and version */
	471	nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
	472	if (nr_items < 2) {
f7b785ac	473	BT_COMP_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
d6e20753	474	"mdec-addr=%p", mdec);
1e649dff PP	475	}
1e649dff PP	476
f7b785ac	477	BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
1e649dff PP	478
1e649dff PP	479	if (!is_version_valid(major, minor)) {
f7b785ac	480	BT_COMP_LOGE("Invalid metadata version found in plain text signature: "
d6e20753 PP	481	"version=%u.%u, mdec-addr=%p", major, minor,
d6e20753 PP	482	mdec);
1e649dff PP	483	status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
	484	goto end;
	485	}
	486
	487	if (fseek(fp, init_pos, SEEK_SET)) {
f7b785ac	488	BT_COMP_LOGE("Cannot seek metadata file stream to initial position: %s: "
d6e20753	489	"mdec-addr=%p", strerror(errno), mdec);
1e649dff PP	490	status = CTF_METADATA_DECODER_STATUS_ERROR;
	491	goto end;
	492	}
	493	}
	494
ef267d12	495	if (BT_LOG_ON_TRACE) {
f73367f8 PP	496	yydebug = 1;
	497	}
	498
1e649dff PP	499	/* Allocate a scanner and append the metadata text content */
	500	scanner = ctf_scanner_alloc();
	501	if (!scanner) {
f7b785ac	502	BT_COMP_LOGE("Cannot allocate a metadata lexical scanner: "
d6e20753	503	"mdec-addr=%p", mdec);
1e649dff PP	504	status = CTF_METADATA_DECODER_STATUS_ERROR;
	505	goto end;
	506	}
	507
f6ccaed9	508	BT_ASSERT(fp);
1e649dff PP	509	ret = ctf_scanner_append_ast(scanner, fp);
1e649dff PP	510	if (ret) {
f7b785ac	511	BT_COMP_LOGE("Cannot create the metadata AST out of the metadata text: "
d6e20753	512	"mdec-addr=%p", mdec);
1e649dff PP	513	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	514	goto end;
	515	}
	516
f7b785ac	517	ret = ctf_visitor_semantic_check(0, &scanner->ast->root, &log_cfg);
1e649dff	518	if (ret) {
f7b785ac	519	BT_COMP_LOGE("Validation of the metadata semantics failed: "
d6e20753	520	"mdec-addr=%p", mdec);
1e649dff PP	521	status = CTF_METADATA_DECODER_STATUS_ERROR;
	522	goto end;
	523	}
	524
	525	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
	526	&scanner->ast->root);
	527	switch (ret) {
	528	case 0:
	529	/* Success */
	530	break;
	531	case -EINCOMPLETE:
f7b785ac	532	BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
d6e20753	533	"mdec-addr=%p", mdec);
1e649dff PP	534	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	535	goto end;
	536	default:
f7b785ac	537	BT_COMP_LOGE("Failed to visit AST node to create CTF IR objects: "
d6e20753	538	"mdec-addr=%p, ret=%d", mdec, ret);
1e649dff PP	539	status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
	540	goto end;
	541	}
	542
	543	end:
	544	if (scanner) {
	545	ctf_scanner_free(scanner);
	546	}
	547
f73367f8 PP	548	yydebug = 0;
f73367f8 PP	549
1e649dff PP	550	if (fp && close_fp) {
1e649dff PP	551	if (fclose(fp)) {
f7b785ac	552	BT_COMP_LOGE("Cannot close metadata file stream: "
d6e20753	553	"mdec-addr=%p", mdec);
1e649dff PP	554	}
	555	}
	556
	557	if (buf) {
	558	free(buf);
	559	}
	560
	561	return status;
	562	}
	563
	564	BT_HIDDEN
b19ff26f	565	bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(
44c440bc PP	566	struct ctf_metadata_decoder *mdec)
44c440bc PP	567	{
862ca4ed	568	return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
44c440bc PP	569	}
	570
	571	BT_HIDDEN
	572	struct ctf_trace_class *ctf_metadata_decoder_borrow_ctf_trace_class(
1e649dff PP	573	struct ctf_metadata_decoder *mdec)
1e649dff PP	574	{
44c440bc	575	return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
1e649dff	576	}