X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=732a30bf114fb89551bf322451dca89afbef10cf;hp=4c000e9b400864591a5bbd7715c2db7e3a1aef26;hb=93bed9fe8f48c11b7bb1224db36d82404cea080d;hpb=09b72f7aa737f46196db18bcdf3bc947a08c27a2

diff --git a/src/common/utils.c b/src/common/utils.c
index 4c000e9b4..732a30bf1 100644
--- a/src/common/utils.c
+++ b/src/common/utils.c
@@ -38,6 +38,9 @@
 #include <common/compat/getenv.h>
 #include <common/compat/string.h>
 #include <common/compat/dirent.h>
+#include <common/compat/directory-handle.h>
+#include <common/dynamic-buffer.h>
+#include <common/string-utils/format.h>
 #include <lttng/constant.h>
 
 #include "utils.h"
@@ -667,44 +670,6 @@ error:
 	return fd;
 }
 
-/*
- * On some filesystems (e.g. nfs), mkdir will validate access rights before
- * checking for the existence of the path element. This means that on a setup
- * where "/home/" is a mounted NFS share, and running as an unpriviledged user,
- * recursively creating a path of the form "/home/my_user/trace/" will fail with
- * EACCES on mkdir("/home", ...).
- *
- * Performing a stat(...) on the path to check for existence allows us to
- * work around this behaviour.
- */
-static
-int mkdir_check_exists(const char *path, mode_t mode)
-{
-	int ret = 0;
-	struct stat st;
-
-	ret = stat(path, &st);
-	if (ret == 0) {
-		if (S_ISDIR(st.st_mode)) {
-			/* Directory exists, skip. */
-			goto end;
-		} else {
-			/* Exists, but is not a directory. */
-			errno = ENOTDIR;
-			ret = -1;
-			goto end;
-		}
-	}
-
-	/*
-	 * Let mkdir handle other errors as the caller expects mkdir
-	 * semantics.
-	 */
-	ret = mkdir(path, mode);
-end:
-	return ret;
-}
-
 /*
  * Create directory using the given path and mode.
  *
@@ -714,82 +679,21 @@ LTTNG_HIDDEN
 int utils_mkdir(const char *path, mode_t mode, int uid, int gid)
 {
 	int ret;
+	struct lttng_directory_handle handle;
+	const struct lttng_credentials creds = {
+		.uid = (uid_t) uid,
+		.gid = (gid_t) gid,
+	};
 
-	if (uid < 0 || gid < 0) {
-		ret = mkdir_check_exists(path, mode);
-	} else {
-		ret = run_as_mkdir(path, mode, uid, gid);
-	}
-	if (ret < 0) {
-		if (errno != EEXIST) {
-			PERROR("mkdir %s, uid %d, gid %d", path ? path : "NULL",
-					uid, gid);
-		} else {
-			ret = 0;
-		}
-	}
-
-	return ret;
-}
-
-/*
- * Internal version of mkdir_recursive. Runs as the current user.
- * Don't call directly; use utils_mkdir_recursive().
- *
- * This function is ominously marked as "unsafe" since it should only
- * be called by a caller that has transitioned to the uid and gid under which
- * the directory creation should occur.
- */
-LTTNG_HIDDEN
-int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode)
-{
-	char *p, tmp[PATH_MAX];
-	size_t len;
-	int ret;
-
-	assert(path);
-
-	ret = snprintf(tmp, sizeof(tmp), "%s", path);
-	if (ret < 0) {
-		PERROR("snprintf mkdir");
-		goto error;
-	}
-
-	len = ret;
-	if (tmp[len - 1] == '/') {
-		tmp[len - 1] = 0;
-	}
-
-	for (p = tmp + 1; *p; p++) {
-		if (*p == '/') {
-			*p = 0;
-			if (tmp[strlen(tmp) - 1] == '.' &&
-					tmp[strlen(tmp) - 2] == '.' &&
-					tmp[strlen(tmp) - 3] == '/') {
-				ERR("Using '/../' is not permitted in the trace path (%s)",
-						tmp);
-				ret = -1;
-				goto error;
-			}
-			ret = mkdir_check_exists(tmp, mode);
-			if (ret < 0) {
-				if (errno != EACCES) {
-					PERROR("mkdir recursive");
-					ret = -errno;
-					goto error;
-				}
-			}
-			*p = '/';
-		}
-	}
-
-	ret = mkdir_check_exists(tmp, mode);
-	if (ret < 0) {
-		PERROR("mkdir recursive last element");
-		ret = -errno;
+	ret = lttng_directory_handle_init(&handle, NULL);
+	if (ret) {
+		goto end;
 	}
-
-error:
+	ret = lttng_directory_handle_create_subdirectory_as_user(
+			&handle, path, mode,
+			(uid >= 0 || gid >= 0) ? &creds : NULL);
+	lttng_directory_handle_fini(&handle);
+end:
 	return ret;
 }
 
@@ -803,82 +707,61 @@ LTTNG_HIDDEN
 int utils_mkdir_recursive(const char *path, mode_t mode, int uid, int gid)
 {
 	int ret;
+	struct lttng_directory_handle handle;
+	const struct lttng_credentials creds = {
+		.uid = (uid_t) uid,
+		.gid = (gid_t) gid,
+	};
 
-	if (uid < 0 || gid < 0) {
-		/* Run as current user. */
-		ret = _utils_mkdir_recursive_unsafe(path, mode);
-	} else {
-		ret = run_as_mkdir_recursive(path, mode, uid, gid);
-	}
-	if (ret < 0) {
-		PERROR("mkdir %s, uid %d, gid %d", path ? path : "NULL",
-				uid, gid);
+	ret = lttng_directory_handle_init(&handle, NULL);
+	if (ret) {
+		goto end;
 	}
-
+	ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
+			&handle, path, mode,
+			(uid >= 0 || gid >= 0) ? &creds : NULL);
+	lttng_directory_handle_fini(&handle);
+end:
 	return ret;
 }
 
 /*
- * path is the output parameter. It needs to be PATH_MAX len.
+ * out_stream_path is the output parameter.
  *
  * Return 0 on success or else a negative value.
  */
-static int utils_stream_file_name(char *path,
-		const char *path_name, const char *file_name,
-		uint64_t size, uint64_t count,
-		const char *suffix)
+LTTNG_HIDDEN
+int utils_stream_file_path(const char *path_name, const char *file_name,
+		uint64_t size, uint64_t count, const char *suffix,
+		char *out_stream_path, size_t stream_path_len)
 {
 	int ret;
-	char full_path[PATH_MAX];
-	char *path_name_suffix = NULL;
-	char *extra = NULL;
+        char count_str[MAX_INT_DEC_LEN(count) + 1] = {};
+	const char *path_separator;
 
-	ret = snprintf(full_path, sizeof(full_path), "%s/%s",
-			path_name, file_name);
-	if (ret < 0) {
-		PERROR("snprintf create output file");
-		goto error;
+	if (path_name && path_name[strlen(path_name) - 1] == '/') {
+		path_separator = "";
+	} else {
+		path_separator = "/";
 	}
 
-	/* Setup extra string if suffix or/and a count is needed. */
-	if (size > 0 && suffix) {
-		ret = asprintf(&extra, "_%" PRIu64 "%s", count, suffix);
-	} else if (size > 0) {
-		ret = asprintf(&extra, "_%" PRIu64, count);
-	} else if (suffix) {
-		ret = asprintf(&extra, "%s", suffix);
-	}
-	if (ret < 0) {
-		PERROR("Allocating extra string to name");
-		goto error;
+	path_name = path_name ? : "";
+	suffix = suffix ? : "";
+	if (size > 0) {
+		ret = snprintf(count_str, sizeof(count_str), "_%" PRIu64,
+				count);
+		assert(ret > 0 && ret < sizeof(count_str));
 	}
 
-	/*
-	 * If we split the trace in multiple files, we have to add the count at
-	 * the end of the tracefile name.
-	 */
-	if (extra) {
-		ret = asprintf(&path_name_suffix, "%s%s", full_path, extra);
-		if (ret < 0) {
-			PERROR("Allocating path name with extra string");
-			goto error_free_suffix;
-		}
-		strncpy(path, path_name_suffix, PATH_MAX - 1);
-		path[PATH_MAX - 1] = '\0';
+        ret = snprintf(out_stream_path, stream_path_len, "%s%s%s%s%s",
+			path_name, path_separator, file_name, count_str,
+			suffix);
+	if (ret < 0 || ret >= stream_path_len) {
+		ERR("Truncation occurred while formatting stream path");
+		ret = -1;
 	} else {
-		ret = lttng_strncpy(path, full_path, PATH_MAX);
-		if (ret) {
-			ERR("Failed to copy stream file name");
-			goto error_free_suffix;
-		}
+		ret = 0;
 	}
-	path[PATH_MAX - 1] = '\0';
-	ret = 0;
-
-	free(path_name_suffix);
-error_free_suffix:
-	free(extra);
-error:
 	return ret;
 }
 
@@ -892,10 +775,10 @@ int utils_create_stream_file(const char *path_name, char *file_name, uint64_t si
 		uint64_t count, int uid, int gid, char *suffix)
 {
 	int ret, flags, mode;
-	char path[PATH_MAX];
+	char path[LTTNG_PATH_MAX];
 
-	ret = utils_stream_file_name(path, path_name, file_name,
-			size, count, suffix);
+	ret = utils_stream_file_path(path_name, file_name,
+			size, count, suffix, path, sizeof(path));
 	if (ret < 0) {
 		goto error;
 	}
@@ -930,10 +813,10 @@ int utils_unlink_stream_file(const char *path_name, char *file_name, uint64_t si
 		uint64_t count, int uid, int gid, char *suffix)
 {
 	int ret;
-	char path[PATH_MAX];
+	char path[LTTNG_PATH_MAX];
 
-	ret = utils_stream_file_name(path, path_name, file_name,
-			size, count, suffix);
+	ret = utils_stream_file_path(path_name, file_name, size, count, suffix,
+			path, sizeof(path));
 	if (ret < 0) {
 		goto error;
 	}
@@ -1477,24 +1360,77 @@ size_t utils_get_current_time_str(const char *format, char *dst, size_t len)
 }
 
 /*
- * Return the group ID matching name, else 0 if it cannot be found.
+ * Return 0 on success and set *gid to the group_ID matching the passed name.
+ * Else -1 if it cannot be found or an error occurred.
  */
 LTTNG_HIDDEN
-gid_t utils_get_group_id(const char *name)
+int utils_get_group_id(const char *name, bool warn, gid_t *gid)
 {
-	struct group *grp;
+	static volatile int warn_once;
+	int ret;
+	long sys_len;
+	size_t len;
+	struct group grp;
+	struct group *result;
+	struct lttng_dynamic_buffer buffer;
+
+	/* Get the system limit, if it exists. */
+	sys_len = sysconf(_SC_GETGR_R_SIZE_MAX);
+	if (sys_len == -1) {
+		len = 1024;
+	} else {
+		len = (size_t) sys_len;
+	}
 
-	grp = getgrnam(name);
-	if (!grp) {
-		static volatile int warn_once;
+	lttng_dynamic_buffer_init(&buffer);
+	ret = lttng_dynamic_buffer_set_size(&buffer, len);
+	if (ret) {
+		ERR("Failed to allocate group info buffer");
+		ret = -1;
+		goto error;
+	}
+
+	while ((ret = getgrnam_r(name, &grp, buffer.data, buffer.size, &result)) == ERANGE) {
+		const size_t new_len = 2 * buffer.size;
 
-		if (!warn_once) {
-			WARN("No tracing group detected");
-			warn_once = 1;
+		/* Buffer is not big enough, increase its size. */
+		if (new_len < buffer.size) {
+			ERR("Group info buffer size overflow");
+			ret = -1;
+			goto error;
 		}
-		return 0;
+
+		ret = lttng_dynamic_buffer_set_size(&buffer, new_len);
+		if (ret) {
+			ERR("Failed to grow group info buffer to %zu bytes",
+					new_len);
+			ret = -1;
+			goto error;
+		}
+	}
+	if (ret) {
+		PERROR("Failed to get group file entry for group name \"%s\"",
+				name);
+		ret = -1;
+		goto error;
 	}
-	return grp->gr_gid;
+
+	/* Group not found. */
+	if (!result) {
+		ret = -1;
+		goto error;
+	}
+
+	*gid = result->gr_gid;
+	ret = 0;
+
+error:
+	if (ret && warn && !warn_once) {
+		WARN("No tracing group detected");
+		warn_once = 1;
+	}
+	lttng_dynamic_buffer_reset(&buffer);
+	return ret;
 }
 
 /*
@@ -1549,79 +1485,16 @@ end:
 LTTNG_HIDDEN
 int utils_recursive_rmdir(const char *path)
 {
-	DIR *dir;
-	size_t path_len;
-	int dir_fd, ret = 0, closeret, is_empty = 1;
-	struct dirent *entry;
-
-	/* Open directory */
-	dir = opendir(path);
-	if (!dir) {
-		PERROR("Cannot open '%s' path", path);
-		return -1;
-	}
-	dir_fd = lttng_dirfd(dir);
-	if (dir_fd < 0) {
-		PERROR("lttng_dirfd");
-		return -1;
-	}
-
-	path_len = strlen(path);
-	while ((entry = readdir(dir))) {
-		struct stat st;
-		size_t name_len;
-		char filename[PATH_MAX];
-
-		if (!strcmp(entry->d_name, ".")
-				|| !strcmp(entry->d_name, "..")) {
-			continue;
-		}
-
-		name_len = strlen(entry->d_name);
-		if (path_len + name_len + 2 > sizeof(filename)) {
-			ERR("Failed to remove file: path name too long (%s/%s)",
-				path, entry->d_name);
-			continue;
-		}
-		if (snprintf(filename, sizeof(filename), "%s/%s",
-				path, entry->d_name) < 0) {
-			ERR("Failed to format path.");
-			continue;
-		}
-
-		if (stat(filename, &st)) {
-			PERROR("stat");
-			continue;
-		}
+	int ret;
+	struct lttng_directory_handle handle;
 
-		if (S_ISDIR(st.st_mode)) {
-			char subpath[PATH_MAX];
-
-			strncpy(subpath, path, PATH_MAX);
-			subpath[PATH_MAX - 1] = '\0';
-			strncat(subpath, "/",
-				PATH_MAX - strlen(subpath) - 1);
-			strncat(subpath, entry->d_name,
-				PATH_MAX - strlen(subpath) - 1);
-			if (utils_recursive_rmdir(subpath)) {
-				is_empty = 0;
-			}
-		} else if (S_ISREG(st.st_mode)) {
-			is_empty = 0;
-		} else {
-			ret = -EINVAL;
-			goto end;
-		}
+	ret = lttng_directory_handle_init(&handle, NULL);
+	if (ret) {
+		goto end;
 	}
+	ret = lttng_directory_handle_remove_subdirectory(&handle, path);
+	lttng_directory_handle_fini(&handle);
 end:
-	closeret = closedir(dir);
-	if (closeret) {
-		PERROR("closedir");
-	}
-	if (is_empty) {
-		DBG3("Attempting rmdir %s", path);
-		ret = rmdir(path);
-	}
 	return ret;
 }