X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=db2ed8e7d11dee928a6f96be4167a94669f015c6;hp=9821815ba06298dfbb7e76de02bbc385b9d49d0d;hb=d77dded285b058e4242c8a3d2233f80e725ceefc;hpb=68e6efddb6a27675d6cf15161d7b0101154b56ac diff --git a/src/common/utils.c b/src/common/utils.c index 9821815ba..db2ed8e7d 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -18,6 +18,7 @@ */ #define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -30,9 +31,12 @@ #include #include #include +#include +#include #include #include +#include #include "utils.h" #include "defaults.h" @@ -89,6 +93,10 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) /* Cut the part we will be trying to resolve */ cut_path = strndup(path, next - path); + if (cut_path == NULL) { + PERROR("strndup"); + goto error; + } /* Try to resolve this part */ try_path = realpath((char *)cut_path, NULL); @@ -142,6 +150,10 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) * 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, size, "%s%s", try_path_prev, cut_path); @@ -215,7 +227,10 @@ char *utils_expand_path(const char *path) /* We prepare the start_path not containing it */ start_path = strndup(absolute_path, next - absolute_path); - + if (!start_path) { + PERROR("strndup"); + goto error; + } /* And we concatenate it with the part after this string */ snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 2); @@ -232,6 +247,10 @@ char *utils_expand_path(const char *path) /* Then we prepare the start_path not containing it */ start_path = strndup(absolute_path, previous - absolute_path); + if (!start_path) { + PERROR("strndup"); + goto error; + } /* And we concatenate it with the part after the '/../' */ snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 4); @@ -460,21 +479,95 @@ int utils_create_pid_file(pid_t pid, const char *filepath) ret = fprintf(fp, "%d\n", pid); if (ret < 0) { PERROR("fprintf pid file"); + goto error; } - fclose(fp); + if (fclose(fp)) { + PERROR("fclose"); + } DBG("Pid %d written in file %s", pid, filepath); + ret = 0; error: return ret; } /* - * Recursively create directory using the given path and mode. + * Create lock file to the given path and filename. + * Returns the associated file descriptor, -1 on error. + */ +LTTNG_HIDDEN +int utils_create_lock_file(const char *filepath) +{ + int ret; + int fd; + + assert(filepath); + + fd = open(filepath, O_CREAT, + O_WRONLY | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); + if (fd < 0) { + PERROR("open lock file %s", filepath); + ret = -1; + goto error; + } + + /* + * Attempt to lock the file. If this fails, there is + * already a process using the same lock file running + * and we should exit. + */ + ret = flock(fd, LOCK_EX | LOCK_NB); + if (ret) { + ERR("Could not get lock file %s, another instance is running.", + filepath); + if (close(fd)) { + PERROR("close lock file"); + } + fd = ret; + goto error; + } + +error: + return fd; +} + +/* + * Create directory using the given path and mode. * * On success, return 0 else a negative error code. */ LTTNG_HIDDEN -int utils_mkdir_recursive(const char *path, mode_t mode) +int utils_mkdir(const char *path, mode_t mode, int uid, int gid) +{ + int ret; + + if (uid < 0 || gid < 0) { + ret = mkdir(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; @@ -519,7 +612,7 @@ int utils_mkdir_recursive(const char *path, mode_t mode) ret = mkdir(tmp, mode); if (ret < 0) { if (errno != EEXIST) { - PERROR("mkdir recursive last piece"); + PERROR("mkdir recursive last element"); ret = -errno; } else { ret = 0; @@ -530,8 +623,34 @@ error: return ret; } +/* + * Recursively create directory using the given path and mode, under the + * provided uid and gid. + * + * On success, return 0 else a negative error code. + */ +LTTNG_HIDDEN +int utils_mkdir_recursive(const char *path, mode_t mode, int uid, int gid) +{ + int ret; + + 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); + } + + return ret; +} + /* * Create the stream tracefile on disk. + * path is the output parameter. It needs to be PATH_MAX len. * * Return 0 on success or else a negative value. */ @@ -822,11 +941,28 @@ LTTNG_HIDDEN char *utils_get_home_dir(void) { char *val = NULL; - val = getenv(DEFAULT_LTTNG_HOME_ENV_VAR); + struct passwd *pwd; + + val = lttng_secure_getenv(DEFAULT_LTTNG_HOME_ENV_VAR); if (val != NULL) { - return val; + goto end; } - return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR); + val = lttng_secure_getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR); + if (val != NULL) { + goto end; + } + + /* Fallback on the password file entry. */ + pwd = getpwuid(getuid()); + if (!pwd) { + goto end; + } + val = pwd->pw_dir; + + DBG3("Home directory is '%s'", val); + +end: + return val; } /** @@ -869,6 +1005,26 @@ end: return home_dir; } +/* + * Obtain the value of LTTNG_KMOD_PROBES environment variable, if exists. + * Otherwise returns NULL. + */ +LTTNG_HIDDEN +char *utils_get_kmod_probes_list(void) +{ + return lttng_secure_getenv(DEFAULT_LTTNG_KMOD_PROBES); +} + +/* + * Obtain the value of LTTNG_EXTRA_KMOD_PROBES environment variable, if + * exists. Otherwise returns NULL. + */ +LTTNG_HIDDEN +char *utils_get_extra_kmod_probes_list(void) +{ + return lttng_secure_getenv(DEFAULT_LTTNG_EXTRA_KMOD_PROBES); +} + /* * With the given format, fill dst with the time of len maximum siz. * @@ -950,12 +1106,77 @@ char *utils_generate_optstring(const struct option *long_options, break; } - optstring[str_pos++] = (char)long_options[i].val; - if (long_options[i].has_arg) { - optstring[str_pos++] = ':'; + if (long_options[i].val != '\0') { + optstring[str_pos++] = (char) long_options[i].val; + if (long_options[i].has_arg) { + optstring[str_pos++] = ':'; + } } } end: return optstring; } + +/* + * Try to remove a hierarchy of empty directories, recursively. Don't unlink + * any file. Try to rmdir any empty directory within the hierarchy. + */ +LTTNG_HIDDEN +int utils_recursive_rmdir(const char *path) +{ + DIR *dir; + 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 = dirfd(dir); + if (dir_fd < 0) { + PERROR("dirfd"); + return -1; + } + + while ((entry = readdir(dir))) { + if (!strcmp(entry->d_name, ".") + || !strcmp(entry->d_name, "..")) + continue; + switch (entry->d_type) { + case DT_DIR: + { + 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; + } + break; + } + case DT_REG: + is_empty = 0; + break; + default: + ret = -EINVAL; + goto end; + } + } +end: + closeret = closedir(dir); + if (closeret) { + PERROR("closedir"); + } + if (is_empty) { + DBG3("Attempting rmdir %s", path); + ret = rmdir(path); + } + return ret; +}