[lttng-tools.git] / src / common / path.cpp

/*
 * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
 * Copyright (C) 2013 Raphaël Beamonte <raphael.beamonte@gmail.com>
 * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 * Copyright (C) 2021 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 */

#define _LGPL_SOURCE
#include <common/macros.hpp>
#include <common/common.hpp>
#include <common/path.hpp>

/*
 * Return a partial realpath(3) of the path even if the full path does not
 * exist. For instance, with /tmp/test1/test2/test3, if test2/ does not exist
 * but the /tmp/test1 does, the real path for /tmp/test1 is concatened with
 * /test2/test3 then returned. In normal time, realpath(3) fails if the end
 * point directory does not exist.
 *
 * Return a newly-allocated string.
 */
static
char *utils_partial_realpath(const char *path)
{
	char *cut_path = NULL, *try_path = NULL, *try_path_prev = NULL;
	const char *next, *prev, *end;
	char *resolved_path = NULL;

	/* Safety net */
	if (path == NULL) {
		goto error;
	}

	/*
	 * Identify the end of the path, we don't want to treat the
	 * last char if it is a '/', we will just keep it on the side
	 * to be added at the end, and return a value coherent with
	 * the path given as argument
	 */
	end = path + strlen(path);
	if (*(end-1) == '/') {
		end--;
	}

	/* Initiate the values of the pointers before looping */
	next = path;
	prev = next;
	/* Only to ensure try_path is not NULL to enter the while */
	try_path = (char *)next;

	/* Resolve the canonical path of the first part of the path */
	while (try_path != NULL && next != end) {
		char *try_path_buf = NULL;

		/*
		 * If there is not any '/' left, we want to try with
		 * the full path
		 */
		next = strpbrk(next + 1, "/");
		if (next == NULL) {
			next = end;
		}

		/* Cut the part we will be trying to resolve */
		cut_path = lttng_strndup(path, next - path);
		if (cut_path == NULL) {
			PERROR("lttng_strndup");
			goto error;
		}

		try_path_buf = zmalloc<char>(LTTNG_PATH_MAX);
		if (!try_path_buf) {
			PERROR("zmalloc");
			goto error;
		}

		/* Try to resolve this part */
		try_path = realpath((char *) cut_path, try_path_buf);
		if (try_path == NULL) {
			free(try_path_buf);
			/*
			 * There was an error, we just want to be assured it
			 * is linked to an unexistent directory, if it's another
			 * reason, we spawn an error
			 */
			switch (errno) {
			case ENOENT:
				/* Ignore the error */
				break;
			default:
				PERROR("realpath (partial_realpath)");
				goto error;
				break;
			}
		} else {
			/* Save the place we are before trying the next step */
			try_path_buf = NULL;
			free(try_path_prev);
			try_path_prev = try_path;
			prev = next;
		}

		/* Free the allocated memory */
		free(cut_path);
		cut_path = NULL;
	}

	/* Allocate memory for the resolved path. */
	resolved_path = zmalloc<char>(LTTNG_PATH_MAX);
	if (resolved_path == NULL) {
		PERROR("zmalloc resolved path");
		goto error;
	}

	/*
	 * If we were able to solve at least partially the path, we can concatenate
	 * what worked and what didn't work
	 */
	if (try_path_prev != NULL) {
		/* If we risk to concatenate two '/', we remove one of them */
		if (try_path_prev[strlen(try_path_prev) - 1] == '/' && prev[0] == '/') {
			try_path_prev[strlen(try_path_prev) - 1] = '\0';
		}

		/*
		 * Duplicate the memory used by prev in case resolved_path and
		 * path are pointers for the same memory space
		 */
		cut_path = strdup(prev);
		if (cut_path == NULL) {
			PERROR("strdup");
			goto error;
		}

		/* Concatenate the strings */
		snprintf(resolved_path, LTTNG_PATH_MAX, "%s%s",
				try_path_prev, cut_path);

		/* Free the allocated memory */
		free(cut_path);
		free(try_path_prev);
		cut_path = NULL;
		try_path_prev = NULL;
	/*
	 * Else, we just copy the path in our resolved_path to
	 * return it as is
	 */
	} else {
		strncpy(resolved_path, path, LTTNG_PATH_MAX);
	}

	/* Then we return the 'partially' resolved path */
	return resolved_path;

error:
	free(resolved_path);
	free(cut_path);
	free(try_path);
	if (try_path_prev != try_path) {
		free(try_path_prev);
	}
	return NULL;
}

static
int expand_double_slashes_dot_and_dotdot(char *path)
{
	size_t expanded_path_len, path_len;
	const char *curr_char, *path_last_char, *next_slash, *prev_slash;

	path_len = strlen(path);
	path_last_char = &path[path_len];

	if (path_len == 0) {
		goto error;
	}

	expanded_path_len = 0;

	/* We iterate over the provided path to expand the "//", "../" and "./" */
	for (curr_char = path; curr_char <= path_last_char; curr_char = next_slash + 1) {
		/* Find the next forward slash. */
		size_t curr_token_len;

		if (curr_char == path_last_char) {
			expanded_path_len++;
			break;
		}

		next_slash = (const char *) memchr(curr_char, '/', path_last_char - curr_char);
		if (next_slash == NULL) {
			/* Reached the end of the provided path. */
			next_slash = path_last_char;
		}

		/* Compute how long is the previous token. */
		curr_token_len = next_slash - curr_char;
		switch(curr_token_len) {
		case 0:
			/*
			 * The pointer has not move meaning that curr_char is
			 * pointing to a slash. It that case there is no token
			 * to copy, so continue the iteration to find the next
			 * token
			 */
			continue;
		case 1:
			/*
			 * The pointer moved 1 character. Check if that
			 * character is a dot ('.'), if it is: omit it, else
			 * copy the token to the normalized path.
			 */
			if (curr_char[0] == '.') {
				continue;
			}
			break;
		case 2:
			/*
			 * The pointer moved 2 characters. Check if these
			 * characters are double dots ('..'). If that is the
			 * case, we need to remove the last token of the
			 * normalized path.
			 */
			if (curr_char[0] == '.' && curr_char[1] == '.') {
				/*
				 * Find the previous path component by
				 * using the memrchr function to find the
				 * previous forward slash and substract that
				 * len to the resulting path.
				 */
				prev_slash = (const char *) lttng_memrchr(path, '/', expanded_path_len);
				/*
				 * If prev_slash is NULL, we reached the
				 * beginning of the path. We can't go back any
				 * further.
				 */
				if (prev_slash != NULL) {
					expanded_path_len = prev_slash - path;
				}
				continue;
			}
			break;
		default:
			break;
		}

		/*
		 * Copy the current token which is neither a '.' nor a '..'.
		 */
		path[expanded_path_len++] = '/';
		memmove(&path[expanded_path_len], curr_char, curr_token_len);
		expanded_path_len += curr_token_len;
	}

	if (expanded_path_len == 0) {
		path[expanded_path_len++] = '/';
	}

	path[expanded_path_len] = '\0';
	return 0;
error:
	return -1;
}

/*
 * Make a full resolution of the given path even if it doesn't exist.
 * This function uses the utils_partial_realpath function to resolve
 * symlinks and relatives paths at the start of the string, and
 * implements functionnalities to resolve the './' and '../' strings
 * in the middle of a path. This function is only necessary because
 * realpath(3) does not accept to resolve unexistent paths.
 * The returned string was allocated in the function, it is thus of
 * the responsibility of the caller to free this memory.
 */
static
char *_utils_expand_path(const char *path, bool keep_symlink)
{
	int ret;
	char *absolute_path = NULL;
	char *last_token;
	bool is_dot, is_dotdot;

	/* Safety net */
	if (path == NULL) {
		goto error;
	}

	/* Allocate memory for the absolute_path */
	absolute_path = zmalloc<char>(LTTNG_PATH_MAX);
	if (absolute_path == NULL) {
		PERROR("zmalloc expand path");
		goto error;
	}

	if (path[0] == '/') {
		ret = lttng_strncpy(absolute_path, path, LTTNG_PATH_MAX);
		if (ret) {
			ERR("Path exceeds maximal size of %i bytes", LTTNG_PATH_MAX);
			goto error;
		}
	} else {
		/*
		 * This is a relative path. We need to get the present working
		 * directory and start the path walk from there.
		 */
		char current_working_dir[LTTNG_PATH_MAX];
		char *cwd_ret;

		cwd_ret = getcwd(current_working_dir, sizeof(current_working_dir));
		if (!cwd_ret) {
			goto error;
		}
		/*
		 * Get the number of character in the CWD and allocate an array
		 * to can hold it and the path provided by the caller.
		 */
		ret = snprintf(absolute_path, LTTNG_PATH_MAX, "%s/%s",
				current_working_dir, path);
		if (ret >= LTTNG_PATH_MAX) {
			ERR("Concatenating current working directory %s and path %s exceeds maximal size of %i bytes",
					current_working_dir, path, LTTNG_PATH_MAX);
			goto error;
		}
	}

	if (keep_symlink) {
		/* Resolve partially our path */
		char *new_absolute_path = utils_partial_realpath(absolute_path);
		if (!new_absolute_path) {
			goto error;
		}

		free(absolute_path);
		absolute_path = new_absolute_path;
	}

	ret = expand_double_slashes_dot_and_dotdot(absolute_path);
	if (ret) {
		goto error;
	}

	/* Identify the last token */
	last_token = strrchr(absolute_path, '/');

	/* Verify that this token is not a relative path */
	is_dotdot = (strcmp(last_token, "/..") == 0);
	is_dot = (strcmp(last_token, "/.") == 0);

	/* If it is, take action */
	if (is_dot || is_dotdot) {
		/* For both, remove this token */
		*last_token = '\0';

		/* If it was a reference to parent directory, go back one more time */
		if (is_dotdot) {
			last_token = strrchr(absolute_path, '/');

			/* If there was only one level left, we keep the first '/' */
			if (last_token == absolute_path) {
				last_token++;
			}

			*last_token = '\0';
		}
	}

	return absolute_path;

error:
	free(absolute_path);
	return NULL;
}
char *utils_expand_path(const char *path)
{
	return _utils_expand_path(path, true);
}

char *utils_expand_path_keep_symlink(const char *path)
{
	return _utils_expand_path(path, false);
}
Commit	Line	Data
4971b7f0 MD	1	/*
	2	* Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
	3	* Copyright (C) 2013 Raphaël Beamonte <raphael.beamonte@gmail.com>
	4	* Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	5	* Copyright (C) 2021 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	6	*
	7	* SPDX-License-Identifier: GPL-2.0-only
	8	*/
	9
	10	#define _LGPL_SOURCE
c9e313bc SM	11	#include <common/macros.hpp>
	12	#include <common/common.hpp>
	13	#include <common/path.hpp>
4971b7f0 MD	14
	15	/*
	16	* Return a partial realpath(3) of the path even if the full path does not
	17	* exist. For instance, with /tmp/test1/test2/test3, if test2/ does not exist
	18	* but the /tmp/test1 does, the real path for /tmp/test1 is concatened with
	19	* /test2/test3 then returned. In normal time, realpath(3) fails if the end
	20	* point directory does not exist.
	21	*
	22	* Return a newly-allocated string.
	23	*/
	24	static
	25	char utils_partial_realpath(const char path)
	26	{
	27	char cut_path = NULL, try_path = NULL, *try_path_prev = NULL;
	28	const char next, prev, *end;
	29	char *resolved_path = NULL;
	30
	31	/* Safety net */
	32	if (path == NULL) {
	33	goto error;
	34	}
	35
	36	/*
	37	* Identify the end of the path, we don't want to treat the
	38	* last char if it is a '/', we will just keep it on the side
	39	* to be added at the end, and return a value coherent with
	40	* the path given as argument
	41	*/
	42	end = path + strlen(path);
	43	if (*(end-1) == '/') {
	44	end--;
	45	}
	46
	47	/* Initiate the values of the pointers before looping */
	48	next = path;
	49	prev = next;
	50	/* Only to ensure try_path is not NULL to enter the while */
	51	try_path = (char *)next;
	52
	53	/* Resolve the canonical path of the first part of the path */
	54	while (try_path != NULL && next != end) {
	55	char *try_path_buf = NULL;
	56
	57	/*
	58	* If there is not any '/' left, we want to try with
	59	* the full path
	60	*/
	61	next = strpbrk(next + 1, "/");
	62	if (next == NULL) {
	63	next = end;
	64	}
	65
	66	/* Cut the part we will be trying to resolve */
	67	cut_path = lttng_strndup(path, next - path);
	68	if (cut_path == NULL) {
	69	PERROR("lttng_strndup");
	70	goto error;
	71	}
	72
64803277	73	try_path_buf = zmalloc<char>(LTTNG_PATH_MAX);
4971b7f0 MD	74	if (!try_path_buf) {
	75	PERROR("zmalloc");
	76	goto error;
	77	}
	78
	79	/* Try to resolve this part */
	80	try_path = realpath((char *) cut_path, try_path_buf);
	81	if (try_path == NULL) {
	82	free(try_path_buf);
	83	/*
	84	* There was an error, we just want to be assured it
	85	* is linked to an unexistent directory, if it's another
	86	* reason, we spawn an error
	87	*/
	88	switch (errno) {
	89	case ENOENT:
	90	/* Ignore the error */
	91	break;
	92	default:
	93	PERROR("realpath (partial_realpath)");
	94	goto error;
	95	break;
	96	}
	97	} else {
	98	/* Save the place we are before trying the next step */
	99	try_path_buf = NULL;
	100	free(try_path_prev);
	101	try_path_prev = try_path;
	102	prev = next;
	103	}
	104
	105	/* Free the allocated memory */
	106	free(cut_path);
	107	cut_path = NULL;
	108	}
	109
	110	/* Allocate memory for the resolved path. */
64803277	111	resolved_path = zmalloc<char>(LTTNG_PATH_MAX);
4971b7f0 MD	112	if (resolved_path == NULL) {
	113	PERROR("zmalloc resolved path");
	114	goto error;
	115	}
	116
	117	/*
	118	* If we were able to solve at least partially the path, we can concatenate
	119	* what worked and what didn't work
	120	*/
	121	if (try_path_prev != NULL) {
	122	/* If we risk to concatenate two '/', we remove one of them */
	123	if (try_path_prev[strlen(try_path_prev) - 1] == '/' && prev[0] == '/') {
	124	try_path_prev[strlen(try_path_prev) - 1] = '\0';
	125	}
	126
	127	/*
	128	* Duplicate the memory used by prev in case resolved_path and
	129	* path are pointers for the same memory space
	130	*/
	131	cut_path = strdup(prev);
	132	if (cut_path == NULL) {
	133	PERROR("strdup");
	134	goto error;
	135	}
	136
	137	/* Concatenate the strings */
	138	snprintf(resolved_path, LTTNG_PATH_MAX, "%s%s",
	139	try_path_prev, cut_path);
	140
	141	/* Free the allocated memory */
	142	free(cut_path);
	143	free(try_path_prev);
	144	cut_path = NULL;
	145	try_path_prev = NULL;
	146	/*
	147	* Else, we just copy the path in our resolved_path to
	148	* return it as is
	149	*/
	150	} else {
	151	strncpy(resolved_path, path, LTTNG_PATH_MAX);
	152	}
	153
	154	/* Then we return the 'partially' resolved path */
	155	return resolved_path;
	156
	157	error:
	158	free(resolved_path);
	159	free(cut_path);
	160	free(try_path);
	161	if (try_path_prev != try_path) {
	162	free(try_path_prev);
	163	}
	164	return NULL;
	165	}
	166
	167	static
	168	int expand_double_slashes_dot_and_dotdot(char *path)
	169	{
	170	size_t expanded_path_len, path_len;
	171	const char curr_char, path_last_char, next_slash, prev_slash;
	172
	173	path_len = strlen(path);
	174	path_last_char = &path[path_len];
	175
176	if (path_len == 0) {
177	goto error;
178	}
179
180	expanded_path_len = 0;
181
182	/* We iterate over the provided path to expand the "//", "../" and "./" */
183	for (curr_char = path; curr_char <= path_last_char; curr_char = next_slash + 1) {
184	/* Find the next forward slash. */
185	size_t curr_token_len;
186
187	if (curr_char == path_last_char) {
188	expanded_path_len++;
189	break;
190	}
191
192	next_slash = (const char *) memchr(curr_char, '/', path_last_char - curr_char);
193	if (next_slash == NULL) {
194	/* Reached the end of the provided path. */
195	next_slash = path_last_char;
196	}
197
198	/* Compute how long is the previous token. */
199	curr_token_len = next_slash - curr_char;
200	switch(curr_token_len) {
201	case 0:
202	/*
203	* The pointer has not move meaning that curr_char is
204	* pointing to a slash. It that case there is no token
205	* to copy, so continue the iteration to find the next
206	* token
207	*/
208	continue;
209	case 1:
210	/*
211	* The pointer moved 1 character. Check if that
212	* character is a dot ('.'), if it is: omit it, else
213	* copy the token to the normalized path.
214	*/
215	if (curr_char[0] == '.') {
216	continue;
217	}
218	break;
219	case 2:
220	/*
221	* The pointer moved 2 characters. Check if these
222	* characters are double dots ('..'). If that is the
223	* case, we need to remove the last token of the
224	* normalized path.
225	*/
226	if (curr_char[0] == '.' && curr_char[1] == '.') {
227	/*
228	* Find the previous path component by
229	* using the memrchr function to find the
230	* previous forward slash and substract that
231	* len to the resulting path.
232	*/
233	prev_slash = (const char *) lttng_memrchr(path, '/', expanded_path_len);
234	/*
235	* If prev_slash is NULL, we reached the
236	* beginning of the path. We can't go back any
237	* further.
238	*/
239	if (prev_slash != NULL) {
240	expanded_path_len = prev_slash - path;
241	}
242	continue;
243	}
244	break;
245	default:
246	break;
247	}
248
249	/*
250	* Copy the current token which is neither a '.' nor a '..'.
251	*/
252	path[expanded_path_len++] = '/';
253	memmove(&path[expanded_path_len], curr_char, curr_token_len);
254	expanded_path_len += curr_token_len;
255	}
256
257	if (expanded_path_len == 0) {
258	path[expanded_path_len++] = '/';
259	}
260
261	path[expanded_path_len] = '\0';
262	return 0;
263	error:
264	return -1;
265	}
266
267	/*
268	* Make a full resolution of the given path even if it doesn't exist.
269	* This function uses the utils_partial_realpath function to resolve
270	* symlinks and relatives paths at the start of the string, and
271	* implements functionnalities to resolve the './' and '../' strings
272	* in the middle of a path. This function is only necessary because
273	* realpath(3) does not accept to resolve unexistent paths.
274	* The returned string was allocated in the function, it is thus of
275	* the responsibility of the caller to free this memory.
276	*/
277	static
278	char _utils_expand_path(const char path, bool keep_symlink)
279	{
280	int ret;
281	char *absolute_path = NULL;
282	char *last_token;
283	bool is_dot, is_dotdot;
284
285	/* Safety net */
286	if (path == NULL) {
287	goto error;
288	}
289
290	/* Allocate memory for the absolute_path */
64803277	291	absolute_path = zmalloc<char>(LTTNG_PATH_MAX);
4971b7f0 MD	292	if (absolute_path == NULL) {
	293	PERROR("zmalloc expand path");
	294	goto error;
	295	}
	296
	297	if (path[0] == '/') {
	298	ret = lttng_strncpy(absolute_path, path, LTTNG_PATH_MAX);
	299	if (ret) {
	300	ERR("Path exceeds maximal size of %i bytes", LTTNG_PATH_MAX);
	301	goto error;
	302	}
	303	} else {
	304	/*
	305	* This is a relative path. We need to get the present working
	306	* directory and start the path walk from there.
	307	*/
	308	char current_working_dir[LTTNG_PATH_MAX];
	309	char *cwd_ret;
	310
	311	cwd_ret = getcwd(current_working_dir, sizeof(current_working_dir));
	312	if (!cwd_ret) {
	313	goto error;
	314	}
	315	/*
	316	* Get the number of character in the CWD and allocate an array
	317	* to can hold it and the path provided by the caller.
	318	*/
	319	ret = snprintf(absolute_path, LTTNG_PATH_MAX, "%s/%s",
	320	current_working_dir, path);
	321	if (ret >= LTTNG_PATH_MAX) {
	322	ERR("Concatenating current working directory %s and path %s exceeds maximal size of %i bytes",
	323	current_working_dir, path, LTTNG_PATH_MAX);
	324	goto error;
	325	}
	326	}
	327
	328	if (keep_symlink) {
	329	/* Resolve partially our path */
	330	char *new_absolute_path = utils_partial_realpath(absolute_path);
	331	if (!new_absolute_path) {
	332	goto error;
	333	}
	334
	335	free(absolute_path);
	336	absolute_path = new_absolute_path;
	337	}
	338
	339	ret = expand_double_slashes_dot_and_dotdot(absolute_path);
	340	if (ret) {
	341	goto error;
	342	}
	343
	344	/* Identify the last token */
	345	last_token = strrchr(absolute_path, '/');
	346
	347	/* Verify that this token is not a relative path */
	348	is_dotdot = (strcmp(last_token, "/..") == 0);
	349	is_dot = (strcmp(last_token, "/.") == 0);
	350
	351	/* If it is, take action */
	352	if (is_dot \|\| is_dotdot) {
	353	/* For both, remove this token */
	354	*last_token = '\0';
	355
356	/* If it was a reference to parent directory, go back one more time */
357	if (is_dotdot) {
358	last_token = strrchr(absolute_path, '/');
359
360	/* If there was only one level left, we keep the first '/' */
361	if (last_token == absolute_path) {
362	last_token++;
363	}
364
365	*last_token = '\0';
366	}
367	}
368
369	return absolute_path;
370
371	error:
372	free(absolute_path);
373	return NULL;
374	}
375	char utils_expand_path(const char path)
376	{
377	return _utils_expand_path(path, true);
378	}
379
380	char utils_expand_path_keep_symlink(const char path)
381	{
382	return _utils_expand_path(path, false);
383	}