X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=766f224c7e167118d30dbd99c6b32595b4fe99e4;hp=9821815ba06298dfbb7e76de02bbc385b9d49d0d;hb=6addfa379ee608b20cfe5e15d135bcb6a9724e90;hpb=68e6efddb6a27675d6cf15161d7b0101154b56ac diff --git a/src/common/utils.c b/src/common/utils.c index 9821815ba..766f224c7 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,14 +479,58 @@ 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; } +/* + * 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; +} + /* * Recursively create directory using the given path and mode. * @@ -822,11 +885,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; + } + 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; } - return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR); + val = pwd->pw_dir; + + DBG3("Home directory is '%s'", val); + +end: + return val; } /** @@ -869,6 +949,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 +1050,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; +}