Skip to contentSkip to conversation

Introduce a new utils_resolve_relative function

PATCH New Raphaël Beamonte 2 participants 3 messages Nov 8, 2013 – Nov 12, 2013 2 messages not in the archive

lore
Share & tools
lore
#1 lore raw

PATCH 1/2 Introduce a new utils_resolve_relative function

In reply to a message not in the archive

This functions allows to resolve relative path such as './' and '../' inside a path string. This allows to use paths such as '~/../test' that are received as '/home/x/../test' for instance.

---
 src/common/utils.c |   48 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/common/utils.h |    1 +
 2 files changed, 49 insertions(+)
src/common/utils.c +48 -0
index da4c036..7b52760 100644
@@ -36,6 +36,54 @@
 #include "defaults.h"
 
 /*
+ * Resolve the './' and '../' strings inside a path using our
+ * very own way to do it, so that it works even if the directory
+ * does not exist
+ */
+LTTNG_HIDDEN
+int utils_resolve_relative(char *path)
+{
+	char *next, *previous, *slash, *start_path;
+
+	/* As long as we find '/./' in the path string */
+	while ((next = strstr(path, "/./"))) {
+
+		/* We prepare the start_path not containing it */
+		start_path = strndup(path, next - path);
+
+		/* And we concatenate it with the part after this string */
+		snprintf(path, PATH_MAX, "%s%s", start_path, next + 2);
+
+		free(start_path);
+	}
+
+	while ((next = strstr(path, "/../"))) {
+		/* If the path starts with '/../', there's a problem */
+		if (next == path) {
+			ERR("%s: Path cannot be resolved", path);
+			return 1;
+		}
+
+		/* We find the last level of directory */
+		previous = path;
+		while ((slash = strpbrk(previous + 1, "/")) && slash != next) {
+			previous = slash;
+		}
+
+		/* Then we prepare the start_path not containing it */
+		start_path = strndup(path, previous - path);
+
+		/* And we concatenate it with the part after the '/../' */
+		snprintf(path, PATH_MAX, "%s%s", start_path, next + 3);
+
+		free(start_path);
+	}
+
+	return 0;
+}
+
+
+/*
  * Return the realpath(3) of the path even if the last directory token does not
  * exist. For example, with /tmp/test1/test2, if test2/ does not exist but the
  * /tmp/test1 does, the real path is returned. In normal time, realpath(3)
src/common/utils.h +1 -0
index 52f2798..ced3584 100644
@@ -26,6 +26,7 @@
 #define MEBI_LOG2 20
 #define GIBI_LOG2 30
 
+int utils_resolve_relative(char *path);
 char *utils_expand_path(const char *path);
 int utils_create_pipe(int *dst);
 int utils_create_pipe_cloexec(int *dst);
Signature · 7 lines
1.7.10.4


_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
#2 lore raw

PATCH 2/2 Correct the behavior of the utils_expand_path function

In reply to a message not in the archive

Even if the utils_expand_path function was intended to allow to use unexistent directory paths, it was in fact only working for some kind of arguments. Paths like "foo", "bar/" or "bar/foo" when the "bar" directory does not exist wasn't working. This patch introduce a new way to expand paths in this function that also works properly for these kind of arguments.

---
 src/common/utils.c |   72 +++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 51 insertions(+), 21 deletions(-)
src/common/utils.c +51 -21
index 7b52760..b68f12e 100644
@@ -92,7 +92,7 @@ int utils_resolve_relative(char *path)
 LTTNG_HIDDEN
 char *utils_expand_path(const char *path)
 {
-	const char *end_path = path;
+	const char *end_path = NULL;
 	char *next, *cut_path = NULL, *expanded_path = NULL;
 
 	/* Safety net */
@@ -100,35 +100,65 @@ char *utils_expand_path(const char *path)
 		goto error;
 	}
 
-	/* Find last token delimited by '/' */
-	while ((next = strpbrk(end_path + 1, "/"))) {
-		end_path = next;
-	}
-
-	/* Cut last token from original path */
-	cut_path = strndup(path, end_path - path);
-
+	/* Allocate memory for the expanded path */
 	expanded_path = zmalloc(PATH_MAX);
 	if (expanded_path == NULL) {
 		PERROR("zmalloc expand path");
 		goto error;
 	}
 
-	expanded_path = realpath((char *)cut_path, expanded_path);
-	if (expanded_path == NULL) {
-		switch (errno) {
-		case ENOENT:
-			ERR("%s: No such file or directory", cut_path);
-			break;
-		default:
-			PERROR("realpath utils expand path");
-			break;
+	/* If given path is already absolute */
+	if (*path == '/') {
+		strncpy(expanded_path, path, PATH_MAX);
+	/* Else, we have some work to do */
+	} else {
+		/* Pointer to the last char of the path */
+		const char *last_char = path+strlen(path)-1;
+
+		end_path = path;
+		/* If the path is just a directory name */
+		if (strchr(path, '/') == NULL || strchr(path, '/') == last_char) {
+			cut_path = strdup(".");
+		/* Else, we have to analyse the full path */
+		} else {
+			/* Split part that will be resolved by realpath (relative path from
+			 * current directory using ./ or ../ only) and part that could not
+			 * (directory names)
+			 */
+			while ((next = strpbrk(end_path, "/")) && (next != last_char)) {
+				end_path = next + 1;
+				if (strncmp(end_path, "./", 2) != 0 && strncmp(end_path, "../", 3) != 0) {
+					break;
+				}
+			}
+
+			/* Cut last token from original path */
+			cut_path = strndup(path, end_path - path);
 		}
-		goto error;
+
+		/* Resolve the canonical path of the first part of the path */
+		expanded_path = realpath((char *)cut_path, expanded_path);
+		if (expanded_path == NULL) {
+			switch (errno) {
+			case ENOENT:
+				ERR("%s: No such file or directory", cut_path);
+				break;
+			default:
+				PERROR("realpath utils expand path");
+				break;
+			}
+			goto error;
+		}
+
+		/* Add end part to expanded path */
+		strncat(expanded_path, "/", PATH_MAX - strlen(expanded_path) - 1);
+		strncat(expanded_path, end_path, PATH_MAX - strlen(expanded_path) - 1);
 	}
 
-	/* Add end part to expanded path */
-	strncat(expanded_path, end_path, PATH_MAX - strlen(expanded_path) - 1);
+	/* Resolve the internal './' and '../' strings */
+	if (utils_resolve_relative(expanded_path) != 0) {
+		goto error;
+	}
 
 	free(cut_path);
 	return expanded_path;
Signature · 7 lines
1.7.10.4


_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
#4 lore raw
In reply to a message not in the archive
Quoted 48 lines · Raphaël Beamonte

This functions allows to resolve relative path such as './' and '../' inside a path string. This allows to use paths such as '~/../test' that are received as '/home/x/../test' for instance.

---
 src/common/utils.c |   48 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/common/utils.h |    1 +
 2 files changed, 49 insertions(+)
src/common/utils.c +29 -0
index da4c036..7b52760 100644
@@ -36,6 +36,54 @@
 #include "defaults.h"
 
 /*
+ * Resolve the './' and '../' strings inside a path using our
+ * very own way to do it, so that it works even if the directory
+ * does not exist
+ */
+LTTNG_HIDDEN
+int utils_resolve_relative(char *path)
+{
+	char *next, *previous, *slash, *start_path;
+
+	/* As long as we find '/./' in the path string */
+	while ((next = strstr(path, "/./"))) {
+
+		/* We prepare the start_path not containing it */
+		start_path = strndup(path, next - path);
+
+		/* And we concatenate it with the part after this string */
+		snprintf(path, PATH_MAX, "%s%s", start_path, next + 2);
+
+		free(start_path);
+	}
+
+	while ((next = strstr(path, "/../"))) {
+		/* If the path starts with '/../', there's a problem */
+		if (next == path) {
+			ERR("%s: Path cannot be resolved", path);
+			return 1;
+		}
+
+		/* We find the last level of directory */

src/common/utils.c line 77

Quoted 10 lines
src/common/utils.c +10 -0
+		previous = path;
+		while ((slash = strpbrk(previous + 1, "/")) && slash != next) {
+			previous = slash;
+		}
+
+		/* Then we prepare the start_path not containing it */
+		start_path = strndup(path, previous - path);
+
+		/* And we concatenate it with the part after the '/../' */
+		snprintf(path, PATH_MAX, "%s%s", start_path, next + 3);

I'm not to keen with modifying directly the given path. I would really prefer having this function return a newly allocated char * and taking a const char *. We could want to keep the path given for whatever reason and also you have no idea if the path given is NULL terminated or not nor its size.

Also, a small unit test testing this function and the other one in the next patch would be awesome if you have 2 minutes for that. Those functions are not that trivial to follow for a human :P, there is a lot of string mangling and it's getting confusing after a while.

Thanks!
David

Quoted 27 lines
src/common/utils.c +9 -0
+
+		free(start_path);
+	}
+
+	return 0;
+}
+
+
+/*
  * Return the realpath(3) of the path even if the last directory token does not
  * exist. For example, with /tmp/test1/test2, if test2/ does not exist but the
  * /tmp/test1 does, the real path is returned. In normal time, realpath(3)
src/common/utils.h +1 -0
index 52f2798..ced3584 100644
@@ -26,6 +26,7 @@
 #define MEBI_LOG2 20
 #define GIBI_LOG2 30
 
+int utils_resolve_relative(char *path);
 char *utils_expand_path(const char *path);
 int utils_create_pipe(int *dst);
 int utils_create_pipe_cloexec(int *dst);
Signature · 1 line
1.7.10.4

_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev