[babeltrace.git] / 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_LOG_TAG "PLUGIN-CTF-METADATA-DECODER"
#include "logging.h"

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <assert.h>
#include <babeltrace/compat/uuid-internal.h>
#include <babeltrace/compat/memstream-internal.h>
#include <babeltrace/ctf-ir/trace.h>
#include <glib.h>
#include <string.h>

#include "ast.h"
#include "decoder.h"
#include "scanner.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)
{
	uint32_t magic;
	size_t len;
	int ret = 0;

	len = fread(&magic, sizeof(magic), 1, fp);
	if (len != 1) {
		BT_LOGD_STR("Cannot reade 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);

	BT_LOGV("Decoding metadata packet: mdec-addr=%p, offset=%ld",
		mdec, offset);
	readlen = fread(&header, sizeof(header), 1, in_fp);
	if (feof(in_fp) != 0) {
		BT_LOGV("Reached end of file: offset=%ld", ftell(in_fp));
		goto end;
	}
	if (readlen < 1) {
		BT_LOGV("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_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_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_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_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_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_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 (;;) {
		readlen = fread(buf, sizeof(uint8_t),
			MIN(sizeof(buf) - 1, toread), in_fp);
		if (ferror(in_fp)) {
			BT_LOGE("Cannot read metadata packet buffer: "
				"offset=%ld, read-size=%u",
				ftell(in_fp), (unsigned int) readlen);
			goto error;
		}

		writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
		if (writelen < readlen || ferror(out_fp)) {
			BT_LOGE("Cannot write decoded metadata text to buffer: "
				"read-offset=%ld, write-size=%u",
				ftell(in_fp), (unsigned int) 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_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)
{
	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_LOGE("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_LOGE("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_LOGE("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);
	if (ret < 0) {
		BT_LOGE("Cannot close memory stream: %s: mdec-addr=%p",
			strerror(errno), mdec);
		goto error;
	}

	goto end;

error:
	ret = -1;

	if (out_fp) {
		if (bt_close_memstream(buf, &size, out_fp)) {
			BT_LOGE("Cannot close memory stream: %s: mdec-addr=%p",
				strerror(errno), 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)
{
	return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
		NULL, fp, buf, byte_order);
}

BT_HIDDEN
struct ctf_metadata_decoder *ctf_metadata_decoder_create(
		const struct ctf_metadata_decoder_config *config,
		const char *name)
{
	struct ctf_metadata_decoder *mdec =
		g_new0(struct ctf_metadata_decoder, 1);
	struct ctf_metadata_decoder_config default_config = {
		.clock_class_offset_s = 0,
		.clock_class_offset_ns = 0,
	};

	if (!config) {
		config = &default_config;
	}

	BT_LOGD("Creating CTF metadata decoder: "
		"clock-class-offset-s=%" PRId64 ", "
		"clock-class-offset-ns=%" PRId64 ", name=\"%s\"",
		config->clock_class_offset_s, config->clock_class_offset_ns,
		name);

	if (!mdec) {
		BT_LOGE_STR("Failed to allocate one CTF metadata decoder.");
		goto end;
	}

	mdec->config = *config;
	mdec->visitor = ctf_visitor_generate_ir_create(config, name);
	if (!mdec->visitor) {
		BT_LOGE("Failed to create a CTF IR metadata AST visitor: "
			"mdec-addr=%p", mdec);
		ctf_metadata_decoder_destroy(mdec);
		mdec = NULL;
		goto end;
	}

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

end:
	return mdec;
}

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

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

	assert(mdec);

	if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
		BT_LOGD("Metadata stream is packetized: mdec-addr=%p", mdec);
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
			mdec, fp, &buf, mdec->bo);
		if (ret) {
			BT_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_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_LOGD("Metadata stream is plain text: mdec-addr=%p", mdec);

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

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

		if (!is_version_valid(major, minor)) {
			BT_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_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_VERBOSE) {
		yydebug = 1;
	}

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

	assert(fp);
	ret = ctf_scanner_append_ast(scanner, fp);
	if (ret) {
		BT_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);
	if (ret) {
		BT_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_LOGD("While visiting metadata AST: incomplete data: "
			"mdec-addr=%p", mdec);
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	default:
		BT_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_LOGE("Cannot close metadata file stream: "
				"mdec-addr=%p", mdec);
		}
	}

	if (buf) {
		free(buf);
	}

	return status;
}

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