Move utils_expand_path and utils_expand_path_keep_symlink to libpath.la
authorMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Wed, 19 Jan 2022 16:35:20 +0000 (11:35 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Thu, 20 Jan 2022 19:46:25 +0000 (14:46 -0500)
Move the GPLv2 helper functions utils_expand_path and
utils_expand_path_keep_symlink to libpath.la. This will allow utils.cpp
to be relicensed to LGPLv2.1 by making sure EfficiOS owns the copyright
for the entire source file.

Statically include libpath.la into libcommon-gpl.la.

The "lttng" executable is GPLv2 and only depends on libcommon-lgpl.la,
so it needs to explicitly list libpath.la as its dependency.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: I2108e0bd35ce75797d4a20e65891c820a1dd79f8

14 files changed:
src/bin/lttng-relayd/main.cpp
src/bin/lttng-relayd/utils.cpp
src/bin/lttng-sessiond/main.cpp
src/bin/lttng-sessiond/sessiond-config.cpp
src/bin/lttng/Makefile.am
src/bin/lttng/commands/create.cpp
src/bin/lttng/uprobe.cpp
src/common/Makefile.am
src/common/path.cpp [new file with mode: 0644]
src/common/path.h [new file with mode: 0644]
src/common/utils.cpp
src/common/utils.h
tests/unit/ini_config/ini_config.cpp
tests/unit/test_utils_expand_path.cpp

index 942bfa4d5ab3abded6b6031e0498042e5e1dfbb9..33684addda431e1f70f7a9d767b26bd9dfab8ea5 100644 (file)
@@ -49,6 +49,7 @@
 #include <common/sessiond-comm/relayd.h>
 #include <common/uri.h>
 #include <common/utils.h>
+#include <common/path.h>
 #include <common/align.h>
 #include <common/ini-config/ini-config.h>
 #include <common/dynamic-buffer.h>
index 599f7ff819f3cf4855ca9f7b47ae27d6343c0493..52ac19e8a65c8641b06a9a7a86dd7bbc7a4a7583 100644 (file)
@@ -14,6 +14,7 @@
 #include <common/common.h>
 #include <common/defaults.h>
 #include <common/utils.h>
+#include <common/path.h>
 
 #include "lttng-relayd.h"
 #include "utils.h"
index f622cfefa8795bd607d04e95e0bce26c5a5f04ca..58cf092eac444762ea9d96960f65dd53326fcffd 100644 (file)
@@ -37,6 +37,7 @@
 #include <common/futex.h>
 #include <common/relayd/relayd.h>
 #include <common/utils.h>
+#include <common/path.h>
 #include <common/daemonize.h>
 #include <common/config/session-config.h>
 #include <common/ini-config/ini-config.h>
index 05b77e69c44bece4d6f85ac06d6de8c28ee10fd1..c512b1ab15fd0178a695be6e531ecaff695b00dc 100644 (file)
@@ -13,6 +13,7 @@
 #include <ctype.h>
 #include <common/error.h>
 #include <common/utils.h>
+#include <common/path.h>
 #include <common/compat/errno.h>
 #include <common/compat/getenv.h>
 
index 098aef5c13f8b4e5eb99bdd988cf106d39a307de..b06c95bd705d1c44c5700ad12e13cae8b8e87897 100644 (file)
@@ -40,6 +40,7 @@ lttng_CXXFLAGS = $(AM_CXXFLAGS) $(POPT_CFLAGS)
 
 lttng_LDADD = $(top_builddir)/src/lib/lttng-ctl/liblttng-ctl.la \
                        $(top_builddir)/src/common/libcommon-lgpl.la \
+                       $(top_builddir)/src/common/libpath.la \
                        $(top_builddir)/src/common/config/libconfig.la \
                        $(top_builddir)/src/common/string-utils/libstring-utils.la \
                        $(top_builddir)/src/common/filter/libfilter.la \
index b46893d5eff2c3398329bad262c8b7015e9cc720..2385fd70e8216a8fd6ef7bc0b4817305e3f9a3b7 100644 (file)
@@ -28,6 +28,7 @@
 #include <common/sessiond-comm/sessiond-comm.h>
 #include <common/uri.h>
 #include <common/utils.h>
+#include <common/path.h>
 #include <lttng/lttng.h>
 
 static char *opt_output_path;
index 7a119ae61dea32fc4999f45cdba159cfa134c1fe..21b5e90e6b2bcc60173ab9954ac03c84084e3785 100644 (file)
@@ -14,6 +14,7 @@
 #include "common/compat/getenv.h"
 #include "common/string-utils/string-utils.h"
 #include "common/utils.h"
+#include "common/path.h"
 #include "lttng/constant.h"
 
 #include "command.h"
index b7b59f95a9837615f2ec4d7dadd74e1325113d1c..1ac4874a02a5f50589a11e7a309167aef0dec50e 100644 (file)
@@ -38,7 +38,7 @@ DIST_SUBDIRS = \
        argpar-utils
 
 # Common library
-noinst_LTLIBRARIES = libcommon-lgpl.la libcommon-gpl.la
+noinst_LTLIBRARIES = libpath.la libcommon-lgpl.la libcommon-gpl.la
 EXTRA_DIST = mi-lttng-4.1.xsd
 
 # The libcommon-lgpl static archive contains only LGPLv2.1 code. It is
@@ -116,6 +116,12 @@ libcommon_lgpl_la_LIBADD = \
        $(top_builddir)/src/common/hashtable/libhashtable-lgpl.la \
        $(top_builddir)/src/vendor/msgpack/libmsgpack.la
 
+# The libpath static archive contains GPLv2 compatible code. It is
+# meant to be used by GPL executables.
+
+libpath_la_SOURCES = \
+       path.cpp path.h
+
 # The libcommon-gpl static archive contains GPLv2 compatible code. It is
 # meant to be used by GPL executables.
 
@@ -138,6 +144,7 @@ libcommon_gpl_la_SOURCES = \
 
 libcommon_gpl_la_LIBADD = \
        libcommon-lgpl.la \
+       libpath.la \
        $(top_builddir)/src/common/ini-config/libini-config.la \
        $(top_builddir)/src/common/hashtable/libhashtable-gpl.la \
        $(top_builddir)/src/common/fd-tracker/libfd-tracker.la
diff --git a/src/common/path.cpp b/src/common/path.cpp
new file mode 100644 (file)
index 0000000..ff2f86d
--- /dev/null
@@ -0,0 +1,383 @@
+/*
+ * 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.h>
+#include <common/common.h>
+#include <common/path.h>
+
+/*
+ * 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 = (char *) zmalloc(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 = (char *) zmalloc(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 = (char *) zmalloc(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);
+}
diff --git a/src/common/path.h b/src/common/path.h
new file mode 100644 (file)
index 0000000..3f81eeb
--- /dev/null
@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2021 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ */
+
+#ifndef _COMMON_PATH_H
+#define _COMMON_PATH_H
+
+char *utils_expand_path(const char *path);
+char *utils_expand_path_keep_symlink(const char *path);
+
+#endif /* _COMMON_PATH_H */
index 93014627fe5162bf8d49c4813074debe3edf1ca7..2ebaa84bb507c44a39715d74e900366f3486c81b 100644 (file)
@@ -1,6 +1,5 @@
 /*
  * 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>
  *
  * SPDX-License-Identifier: GPL-2.0-only
 #define FALLBACK_USER_BUFLEN 16384
 #define FALLBACK_GROUP_BUFLEN 16384
 
-/*
- * 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 = (char *) zmalloc(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 = (char *) zmalloc(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 = (char *) zmalloc(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);
-}
 /*
  * Create a pipe in dst.
  */
index beca1fb4b9bb9069a93f144a01afd769ee11a9f5..a0b2622a9748f843f3ce5c582e73478d03eb1180 100644 (file)
@@ -21,8 +21,6 @@
 #define MEBI_LOG2 20
 #define GIBI_LOG2 30
 
-char *utils_expand_path(const char *path);
-char *utils_expand_path_keep_symlink(const char *path);
 int utils_create_pipe(int *dst);
 int utils_create_pipe_cloexec(int *dst);
 int utils_create_pipe_cloexec_nonblock(int *dst);
index c2a753edece66593a336529a21a2bde8c0eca677..e1c65e917bbd0828499b8d2685383b89c53e0e5a 100644 (file)
@@ -8,6 +8,7 @@
 #include <tap/tap.h>
 #include <common/ini-config/ini-config.h>
 #include <common/utils.h>
+#include <common/path.h>
 #include <string.h>
 #include <lttng/constant.h>
 
index 85c8a54282fc947aa7591c4476368fef62032d3b..8216f3fd7b7a35625f55bf865971ccdf21718456 100644 (file)
@@ -16,6 +16,7 @@
 #include <tap/tap.h>
 
 #include <common/utils.h>
+#include <common/path.h>
 #include <common/common.h>
 
 /* For error.h */
This page took 0.057626 seconds and 4 git commands to generate.