[lttng-tools.git] / src / bin / lttng-relayd / backward-compatibility-group-by.cpp

/*
 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include "backward-compatibility-group-by.hpp"
#include "common/time.hpp"

#include <common/common.hpp>
#include <common/defaults.hpp>
#include <common/utils.hpp>

#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DATETIME_REGEX ".*-[1-2][0-9][0-9][0-9][0-1][0-9][0-3][0-9]-[0-2][0-9][0-5][0-9][0-5][0-9]$"

/*
 * Provide support for --group-output-by-session for producer >= 2.4 and < 2.11.
 * Take the stream path, extract all available information, craft a new path to
 * the best of our ability enforcing the group by session.
 *
 * Return the allocated string containing the new stream path or else NULL.
 */
char *backward_compat_group_by_session(const char *path,
				       const char *local_session_name,
				       time_t relay_session_creation_time)
{
	int ret;
	size_t len;
	char *leftover_ptr;
	char *local_copy = nullptr;
	char *datetime = nullptr;
	char *partial_base_path = nullptr;
	char *filepath_per_session = nullptr;
	const char *second_token_ptr;
	const char *leftover_second_token_ptr;
	const char *hostname_ptr;
	regex_t regex;

	LTTNG_ASSERT(path);
	LTTNG_ASSERT(local_session_name);
	LTTNG_ASSERT(local_session_name[0] != '\0');

	DBG("Parsing path \"%s\" of session \"%s\" to create a new path that is grouped by session",
	    path,
	    local_session_name);

	/* Get a local copy for strtok */
	local_copy = strdup(path);
	if (!local_copy) {
		PERROR("Failed to parse session path: couldn't copy input path");
		goto error;
	}

	/*
	 * The use of strtok with '/' as delimiter is valid since we refuse '/'
	 * in session name and '/' is not a valid hostname character based on
	 * RFC-952 [1], RFC-921 [2] and refined in RFC-1123 [3].
	 * [1] https://tools.ietf.org/html/rfc952
	 * [2] https://tools.ietf.org/html/rfc921
	 * [3] https://tools.ietf.org/html/rfc1123#page-13
	 */

	/*
	 * Get the hostname and possible session_name.
	 * Note that we can get the hostname and session name from the
	 * relay_session object we already have. Still, it is easier to
	 * tokenized the passed path to obtain the start of the path leftover.
	 */
	hostname_ptr = strtok_r(local_copy, "/", &leftover_ptr);
	if (!hostname_ptr) {
		ERR("Failed to parse session path \"%s\": couldn't identify hostname", path);
		goto error;
	}

	second_token_ptr = strtok_r(nullptr, "/", &leftover_ptr);
	if (!second_token_ptr) {
		ERR("Failed to parse session path \"%s\": couldn't identify session name", path);
		goto error;
	}

	/*
	 * Check if the second token is a base path set at url level. This is
	 * legal in streaming, live and snapshot [1]. Otherwise it is the
	 * session name with possibly a datetime attached [2]. Note that when
	 * "adding" snapshot output (lttng snapshot add-output), no session name
	 * is present in the path by default. The handling for "base path" take
	 * care of this case as well.
	 * [1] e.g --set-url net://localhost/my_marvellous_path
	 * [2] Can be:
	 *            <session_name>
	 *                When using --snapshot on session create.
	 *            <session_name>-<date>-<time>
	 *            <auto>-<date>-<time>
	 */
	if (strncmp(second_token_ptr, local_session_name, strlen(local_session_name)) != 0) {
		/*
		 * Token does not start with session name.
		 * This mean this is an extra path scenario.
		 * Duplicate the current token since it is part of an
		 * base_path.
		 * Set secDuplicate the current token since it is part of an
		 * base_path. The rest is the leftover.
		 * Set second_token_ptr to the local_session_name for further
		 * processing.
		 */
		partial_base_path = strdup(second_token_ptr);
		if (!partial_base_path) {
			PERROR("Failed to parse session path: couldn't copy partial base path");
			goto error;
		}

		second_token_ptr = local_session_name;
	}

	/*
	 * Based on the previous test, we can move inside the token ptr to
	 * remove the "local_session_name" and inspect the rest of the token.
	 * We are looking into extracting the creation datetime from either the
	 * session_name or the token. We need to to all this gymnastic because
	 * an extra path could decide to append a datetime to its first
	 * subdirectory.
	 * Possible scenario:
	 *     <session_name>
	 *     <session_name>-<date>-<time>
	 *     <auto>-<date>-<time>
	 *     <session_name>_base_path_foo_bar
	 *     <session_name>-<false date>-<false-time> (via a base path)
	 *
	 * We have no way to discern from the basic scenario of:
	 *     <session_name>-<date>-<time>
	 * and one done using a base path with the exact format we normally
	 * expect.
	 *
	 * e.g:
	 *     lttng create my_session -U
	 *         net://localhost/my_session-19910319-120000/
	 */
	ret = regcomp(&regex, DATETIME_REGEX, 0);
	if (ret) {
		ERR("Failed to parse session path: regex compilation failed with code %d", ret);
		goto error;
	}

	leftover_second_token_ptr = second_token_ptr + strlen(local_session_name);
	len = strlen(leftover_second_token_ptr);
	if (len == 0) {
		/*
		 * We are either dealing with an auto session name or only the
		 * session_name. If this is a auto session name, we need to
		 * fetch the creation datetime.
		 */
		ret = regexec(&regex, local_session_name, 0, nullptr, 0);
		if (ret == 0) {
			const ssize_t local_session_name_offset =
				strlen(local_session_name) - DATETIME_STR_LEN + 1;

			LTTNG_ASSERT(local_session_name_offset >= 0);
			datetime = strdup(local_session_name + local_session_name_offset);
			if (!datetime) {
				PERROR("Failed to parse session path: couldn't copy datetime on regex match");
				goto error_regex;
			}
		} else {
			datetime = calloc<char>(DATETIME_STR_LEN);
			if (!datetime) {
				PERROR("Failed to allocate DATETIME string");
				goto error;
			}

			ret = time_to_datetime_str(
				relay_session_creation_time, datetime, DATETIME_STR_LEN);
			if (ret) {
				/* time_to_datetime_str already logs errors. */
				goto error;
			}
		}
	} else if (len == DATETIME_STR_LEN &&
		   !regexec(&regex, leftover_second_token_ptr, 0, nullptr, 0)) {
		/*
		 * The leftover from the second token is of format
		 * "-<datetime>", use it as the creation time.
		 * Ignore leading "-".
		 */
		datetime = strdup(&leftover_second_token_ptr[1]);
		if (!datetime) {
			PERROR("Failed to parse session path: couldn't copy datetime on regex match");
			goto error_regex;
		}
	} else {
		/*
		 * Base path scenario.
		 * We cannot try to extract the datetime from the session name
		 * since nothing prevent a user to name a session in the
		 * "name-<datetime>" format. Using the datetime from such a
		 * session would be invalid.
		 * */
		LTTNG_ASSERT(partial_base_path == nullptr);
		LTTNG_ASSERT(datetime == nullptr);

		partial_base_path = strdup(second_token_ptr);
		if (!partial_base_path) {
			PERROR("Failed to parse session path: couldn't copy partial base path");
			goto error_regex;
		}
	}

	ret = asprintf(&filepath_per_session,
		       "%s/%s%s%s/%s%s%s",
		       local_session_name,
		       hostname_ptr,
		       datetime ? "-" : "",
		       datetime ? datetime : "",
		       partial_base_path ? partial_base_path : "",
		       partial_base_path ? "/" : "",
		       leftover_ptr);
	if (ret < 0) {
		filepath_per_session = nullptr;
		goto error;
	}
error_regex:
	regfree(&regex);
error:
	free(local_copy);
	free(partial_base_path);
	free(datetime);
	return filepath_per_session;
}
Commit	Line	Data
2a635488	1	/*
ab5be9fa	2	* Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
2a635488	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
2a635488	5	*
2a635488 JR	6	*/
2a635488 JR	7
28ab034a	8	#include "backward-compatibility-group-by.hpp"
c9e313bc	9	#include "common/time.hpp"
2a635488	10
c9e313bc SM	11	#include <common/common.hpp>
	12	#include <common/defaults.hpp>
	13	#include <common/utils.hpp>
2a635488	14
28ab034a JG	15	#include <regex.h>
	16	#include <stdio.h>
	17	#include <stdlib.h>
	18	#include <string.h>
2a635488	19
28ab034a	20	#define DATETIME_REGEX ".*-[1-2][0-9][0-9][0-9][0-1][0-9][0-3][0-9]-[0-2][0-9][0-5][0-9][0-5][0-9]$"
2a635488 JR	21
	22	/*
	23	* Provide support for --group-output-by-session for producer >= 2.4 and < 2.11.
	24	* Take the stream path, extract all available information, craft a new path to
	25	* the best of our ability enforcing the group by session.
	26	*
	27	* Return the allocated string containing the new stream path or else NULL.
	28	*/
d2cb4a90	29	char backward_compat_group_by_session(const char path,
28ab034a JG	30	const char *local_session_name,
28ab034a JG	31	time_t relay_session_creation_time)
2a635488 JR	32	{
	33	int ret;
	34	size_t len;
	35	char *leftover_ptr;
cd9adb8b JG	36	char *local_copy = nullptr;
	37	char *datetime = nullptr;
	38	char *partial_base_path = nullptr;
	39	char *filepath_per_session = nullptr;
2a635488 JR	40	const char *second_token_ptr;
	41	const char *leftover_second_token_ptr;
	42	const char *hostname_ptr;
	43	regex_t regex;
	44
a0377dfe FD	45	LTTNG_ASSERT(path);
	46	LTTNG_ASSERT(local_session_name);
	47	LTTNG_ASSERT(local_session_name[0] != '\0');
2a635488 JR	48
2a635488 JR	49	DBG("Parsing path \"%s\" of session \"%s\" to create a new path that is grouped by session",
28ab034a JG	50	path,
28ab034a JG	51	local_session_name);
2a635488 JR	52
	53	/* Get a local copy for strtok */
	54	local_copy = strdup(path);
	55	if (!local_copy) {
	56	PERROR("Failed to parse session path: couldn't copy input path");
	57	goto error;
	58	}
	59
	60	/*
	61	* The use of strtok with '/' as delimiter is valid since we refuse '/'
	62	* in session name and '/' is not a valid hostname character based on
4f173935	63	* RFC-952 [1], RFC-921 [2] and refined in RFC-1123 [3].
2a635488 JR	64	* [1] https://tools.ietf.org/html/rfc952
	65	* [2] https://tools.ietf.org/html/rfc921
	66	* [3] https://tools.ietf.org/html/rfc1123#page-13
	67	*/
	68
	69	/*
	70	* Get the hostname and possible session_name.
	71	* Note that we can get the hostname and session name from the
	72	* relay_session object we already have. Still, it is easier to
	73	* tokenized the passed path to obtain the start of the path leftover.
	74	*/
	75	hostname_ptr = strtok_r(local_copy, "/", &leftover_ptr);
	76	if (!hostname_ptr) {
28ab034a	77	ERR("Failed to parse session path \"%s\": couldn't identify hostname", path);
2a635488 JR	78	goto error;
	79	}
	80
cd9adb8b	81	second_token_ptr = strtok_r(nullptr, "/", &leftover_ptr);
2a635488	82	if (!second_token_ptr) {
28ab034a	83	ERR("Failed to parse session path \"%s\": couldn't identify session name", path);
2a635488 JR	84	goto error;
	85	}
	86
	87	/*
	88	* Check if the second token is a base path set at url level. This is
	89	* legal in streaming, live and snapshot [1]. Otherwise it is the
	90	* session name with possibly a datetime attached [2]. Note that when
	91	* "adding" snapshot output (lttng snapshot add-output), no session name
	92	* is present in the path by default. The handling for "base path" take
	93	* care of this case as well.
	94	* [1] e.g --set-url net://localhost/my_marvellous_path
	95	* [2] Can be:
	96	* <session_name>
	97	* When using --snapshot on session create.
	98	* <session_name>-<date>-<time>
	99	* <auto>-<date>-<time>
	100	*/
28ab034a	101	if (strncmp(second_token_ptr, local_session_name, strlen(local_session_name)) != 0) {
2a635488 JR	102	/*
	103	* Token does not start with session name.
	104	* This mean this is an extra path scenario.
	105	* Duplicate the current token since it is part of an
	106	* base_path.
	107	* Set secDuplicate the current token since it is part of an
	108	* base_path. The rest is the leftover.
	109	* Set second_token_ptr to the local_session_name for further
	110	* processing.
	111	*/
	112	partial_base_path = strdup(second_token_ptr);
	113	if (!partial_base_path) {
	114	PERROR("Failed to parse session path: couldn't copy partial base path");
	115	goto error;
	116	}
	117
	118	second_token_ptr = local_session_name;
	119	}
	120
	121	/*
	122	* Based on the previous test, we can move inside the token ptr to
	123	* remove the "local_session_name" and inspect the rest of the token.
	124	* We are looking into extracting the creation datetime from either the
	125	* session_name or the token. We need to to all this gymnastic because
	126	* an extra path could decide to append a datetime to its first
	127	* subdirectory.
	128	* Possible scenario:
	129	* <session_name>
	130	* <session_name>-<date>-<time>
	131	* <auto>-<date>-<time>
	132	* <session_name>_base_path_foo_bar
	133	* <session_name>-<false date>-<false-time> (via a base path)
	134	*
	135	* We have no way to discern from the basic scenario of:
	136	* <session_name>-<date>-<time>
	137	* and one done using a base path with the exact format we normally
	138	* expect.
	139	*
	140	* e.g:
	141	* lttng create my_session -U
	142	* net://localhost/my_session-19910319-120000/
	143	*/
	144	ret = regcomp(&regex, DATETIME_REGEX, 0);
	145	if (ret) {
	146	ERR("Failed to parse session path: regex compilation failed with code %d", ret);
	147	goto error;
	148	}
	149
28ab034a	150	leftover_second_token_ptr = second_token_ptr + strlen(local_session_name);
2a635488 JR	151	len = strlen(leftover_second_token_ptr);
	152	if (len == 0) {
	153	/*
	154	* We are either dealing with an auto session name or only the
	155	* session_name. If this is a auto session name, we need to
	156	* fetch the creation datetime.
	157	*/
cd9adb8b	158	ret = regexec(&regex, local_session_name, 0, nullptr, 0);
2a635488 JR	159	if (ret == 0) {
2a635488 JR	160	const ssize_t local_session_name_offset =
28ab034a	161	strlen(local_session_name) - DATETIME_STR_LEN + 1;
2a635488	162
a0377dfe	163	LTTNG_ASSERT(local_session_name_offset >= 0);
28ab034a	164	datetime = strdup(local_session_name + local_session_name_offset);
2a635488 JR	165	if (!datetime) {
	166	PERROR("Failed to parse session path: couldn't copy datetime on regex match");
	167	goto error_regex;
	168	}
d2cb4a90	169	} else {
64803277	170	datetime = calloc<char>(DATETIME_STR_LEN);
d2cb4a90 JG	171	if (!datetime) {
	172	PERROR("Failed to allocate DATETIME string");
	173	goto error;
	174	}
	175
28ab034a JG	176	ret = time_to_datetime_str(
28ab034a JG	177	relay_session_creation_time, datetime, DATETIME_STR_LEN);
d2cb4a90 JG	178	if (ret) {
	179	/* time_to_datetime_str already logs errors. */
	180	goto error;
	181	}
2a635488	182	}
d2cb4a90	183	} else if (len == DATETIME_STR_LEN &&
cd9adb8b	184	!regexec(&regex, leftover_second_token_ptr, 0, nullptr, 0)) {
2a635488 JR	185	/*
	186	* The leftover from the second token is of format
	187	* "-<datetime>", use it as the creation time.
	188	* Ignore leading "-".
	189	*/
	190	datetime = strdup(&leftover_second_token_ptr[1]);
	191	if (!datetime) {
	192	PERROR("Failed to parse session path: couldn't copy datetime on regex match");
	193	goto error_regex;
	194	}
	195	} else {
	196	/*
	197	* Base path scenario.
	198	* We cannot try to extract the datetime from the session name
	199	* since nothing prevent a user to name a session in the
	200	* "name-<datetime>" format. Using the datetime from such a
	201	* session would be invalid.
	202	* */
cd9adb8b JG	203	LTTNG_ASSERT(partial_base_path == nullptr);
cd9adb8b JG	204	LTTNG_ASSERT(datetime == nullptr);
2a635488 JR	205
	206	partial_base_path = strdup(second_token_ptr);
	207	if (!partial_base_path) {
	208	PERROR("Failed to parse session path: couldn't copy partial base path");
	209	goto error_regex;
	210	}
	211	}
	212
28ab034a JG	213	ret = asprintf(&filepath_per_session,
	214	"%s/%s%s%s/%s%s%s",
	215	local_session_name,
	216	hostname_ptr,
	217	datetime ? "-" : "",
	218	datetime ? datetime : "",
	219	partial_base_path ? partial_base_path : "",
	220	partial_base_path ? "/" : "",
	221	leftover_ptr);
2a635488	222	if (ret < 0) {
cd9adb8b	223	filepath_per_session = nullptr;
2a635488 JR	224	goto error;
	225	}
	226	error_regex:
	227	regfree(&regex);
	228	error:
	229	free(local_copy);
	230	free(partial_base_path);
	231	free(datetime);
	232	return filepath_per_session;
	233	}