X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=2f132a0603c8d9891d1280ef1912709b3b3c9013;hb=40804255e7a6acd6fa76c41ee8e4e1cc2cefa49c;hp=4c000e9b400864591a5bbd7715c2db7e3a1aef26;hpb=09b72f7aa737f46196db18bcdf3bc947a08c27a2;p=lttng-tools.git diff --git a/src/common/utils.c b/src/common/utils.c index 4c000e9b4..2f132a060 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -38,6 +38,9 @@ #include #include #include +#include +#include +#include #include #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; + } + + 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; + } - grp = getgrnam(name); - if (!grp) { - static volatile int warn_once; + 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; + } + + 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; } - return 0; } - return grp->gr_gid; + if (ret) { + PERROR("Failed to get group file entry for group name \"%s\"", + name); + ret = -1; + goto error; + } + + /* 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; } /*