#define O_NOFOLLOW 00400000
#endif
-lxc_log_define(lxc_utils, lxc);
+lxc_log_define(utils, lxc);
/*
* if path is btrfs, tries to remove it and any subvolumes beneath it
return failed ? -1 : 0;
}
-/* We have two different magic values for overlayfs, yay. */
-#ifndef OVERLAYFS_SUPER_MAGIC
-#define OVERLAYFS_SUPER_MAGIC 0x794c764f
-#endif
-
-#ifndef OVERLAY_SUPER_MAGIC
-#define OVERLAY_SUPER_MAGIC 0x794c7630
-#endif
-
/* In overlayfs, st_dev is unreliable. So on overlayfs we don't do the
* lxc_rmdir_onedev()
*/
return status;
}
-ssize_t lxc_write_nointr(int fd, const void *buf, size_t count)
-{
- ssize_t ret;
-again:
- ret = write(fd, buf, count);
- if (ret < 0 && errno == EINTR)
- goto again;
-
- return ret;
-}
-
-ssize_t lxc_read_nointr(int fd, void *buf, size_t count)
-{
- ssize_t ret;
-again:
- ret = read(fd, buf, count);
- if (ret < 0 && errno == EINTR)
- goto again;
-
- return ret;
-}
-
-ssize_t lxc_read_nointr_expect(int fd, void *buf, size_t count, const void *expected_buf)
-{
- ssize_t ret;
-
- ret = lxc_read_nointr(fd, buf, count);
- if (ret <= 0)
- return ret;
-
- if ((size_t)ret != count)
- return -1;
-
- if (expected_buf && memcmp(buf, expected_buf, count) != 0) {
- errno = EINVAL;
- return -1;
- }
-
- return ret;
-}
-
#if HAVE_LIBGNUTLS
#include <gnutls/gnutls.h>
#include <gnutls/crypto.h>
}
#endif
-char** lxc_va_arg_list_to_argv(va_list ap, size_t skip, int do_strdup)
-{
- va_list ap2;
- size_t count = 1 + skip;
- char **result;
-
- /* first determine size of argument list, we don't want to reallocate
- * constantly...
- */
- va_copy(ap2, ap);
- while (1) {
- char* arg = va_arg(ap2, char*);
- if (!arg)
- break;
- count++;
- }
- va_end(ap2);
-
- result = calloc(count, sizeof(char*));
- if (!result)
- return NULL;
-
- count = skip;
- while (1) {
- char* arg = va_arg(ap, char*);
- if (!arg)
- break;
- arg = do_strdup ? strdup(arg) : arg;
- if (!arg)
- goto oom;
- result[count++] = arg;
- }
-
- /* calloc has already set last element to NULL*/
- return result;
-
-oom:
- free(result);
- return NULL;
-}
-
-const char** lxc_va_arg_list_to_argv_const(va_list ap, size_t skip)
-{
- return (const char**)lxc_va_arg_list_to_argv(ap, skip, 0);
-}
-
struct lxc_popen_FILE *lxc_popen(const char *command)
{
int ret;
return wstatus;
}
-char *lxc_string_replace(const char *needle, const char *replacement, const char *haystack)
-{
- ssize_t len = -1, saved_len = -1;
- char *result = NULL;
- size_t replacement_len = strlen(replacement);
- size_t needle_len = strlen(needle);
-
- /* should be executed exactly twice */
- while (len == -1 || result == NULL) {
- char *p;
- char *last_p;
- ssize_t part_len;
-
- if (len != -1) {
- result = calloc(1, len + 1);
- if (!result)
- return NULL;
-
- saved_len = len;
- }
-
- len = 0;
-
- for (last_p = (char *)haystack, p = strstr(last_p, needle); p; last_p = p, p = strstr(last_p, needle)) {
- part_len = (ssize_t)(p - last_p);
- if (result && part_len > 0)
- memcpy(&result[len], last_p, part_len);
-
- len += part_len;
-
- if (result && replacement_len > 0)
- memcpy(&result[len], replacement, replacement_len);
-
- len += replacement_len;
- p += needle_len;
- }
-
- part_len = strlen(last_p);
- if (result && part_len > 0)
- memcpy(&result[len], last_p, part_len);
-
- len += part_len;
- }
-
- /* make sure we did the same thing twice,
- * once for calculating length, the other
- * time for copying data */
- if (saved_len != len) {
- free(result);
- return NULL;
- }
-
- /* make sure we didn't overwrite any buffer,
- * due to calloc the string should be 0-terminated */
- if (result[len] != '\0') {
- free(result);
- return NULL;
- }
-
- return result;
-}
-
-bool lxc_string_in_array(const char *needle, const char **haystack)
-{
- for (; haystack && *haystack; haystack++)
- if (!strcmp(needle, *haystack))
- return true;
-
- return false;
-}
-
-char *lxc_string_join(const char *sep, const char **parts, bool use_as_prefix)
-{
- char *result;
- char **p;
- size_t sep_len = strlen(sep);
- size_t result_len = use_as_prefix * sep_len;
- size_t buf_len;
-
- /* calculate new string length */
- for (p = (char **)parts; *p; p++)
- result_len += (p > (char **)parts) * sep_len + strlen(*p);
-
- buf_len = result_len + 1;
- result = calloc(buf_len, 1);
- if (!result)
- return NULL;
-
- if (use_as_prefix)
- (void)strlcpy(result, sep, buf_len);
-
- for (p = (char **)parts; *p; p++) {
- if (p > (char **)parts)
- (void)strlcat(result, sep, buf_len);
-
- (void)strlcat(result, *p, buf_len);
- }
-
- return result;
-}
-
-char **lxc_normalize_path(const char *path)
-{
- char **components;
- char **p;
- size_t components_len = 0;
- size_t pos = 0;
-
- components = lxc_string_split(path, '/');
- if (!components)
- return NULL;
-
- for (p = components; *p; p++)
- components_len++;
-
- /* resolve '.' and '..' */
- for (pos = 0; pos < components_len; ) {
- if (!strcmp(components[pos], ".") || (!strcmp(components[pos], "..") && pos == 0)) {
- /* eat this element */
- free(components[pos]);
- memmove(&components[pos], &components[pos+1], sizeof(char *) * (components_len - pos));
- components_len--;
- } else if (!strcmp(components[pos], "..")) {
- /* eat this and the previous element */
- free(components[pos - 1]);
- free(components[pos]);
- memmove(&components[pos-1], &components[pos+1], sizeof(char *) * (components_len - pos));
- components_len -= 2;
- pos--;
- } else {
- pos++;
- }
- }
-
- return components;
-}
-
-char *lxc_deslashify(const char *path)
-{
- char *dup, *p;
- char **parts = NULL;
- size_t n, len;
-
- dup = strdup(path);
- if (!dup)
- return NULL;
-
- parts = lxc_normalize_path(dup);
- if (!parts) {
- free(dup);
- return NULL;
- }
-
- /* We'll end up here if path == "///" or path == "". */
- if (!*parts) {
- len = strlen(dup);
- if (!len) {
- lxc_free_array((void **)parts, free);
- return dup;
- }
-
- n = strcspn(dup, "/");
- if (n == len) {
- free(dup);
- lxc_free_array((void **)parts, free);
-
- p = strdup("/");
- if (!p)
- return NULL;
-
- return p;
- }
- }
-
- p = lxc_string_join("/", (const char **)parts, *dup == '/');
- free(dup);
- lxc_free_array((void **)parts, free);
- return p;
-}
-
-char *lxc_append_paths(const char *first, const char *second)
-{
- int ret;
- size_t len;
- char *result = NULL;
- const char *pattern = "%s%s";
-
- len = strlen(first) + strlen(second) + 1;
- if (second[0] != '/') {
- len += 1;
- pattern = "%s/%s";
- }
-
- result = calloc(1, len);
- if (!result)
- return NULL;
-
- ret = snprintf(result, len, pattern, first, second);
- if (ret < 0 || (size_t)ret >= len) {
- free(result);
- return NULL;
- }
-
- return result;
-}
-
-bool lxc_string_in_list(const char *needle, const char *haystack, char _sep)
-{
- char *token, *str, *saveptr = NULL;
- char sep[2] = { _sep, '\0' };
- size_t len;
-
- if (!haystack || !needle)
- return 0;
-
- len = strlen(haystack);
- str = alloca(len + 1);
- (void)strlcpy(str, haystack, len + 1);
-
- for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
- if (strcmp(needle, token) == 0)
- return 1;
- }
-
- return 0;
-}
-
-char **lxc_string_split(const char *string, char _sep)
-{
- char *token, *str, *saveptr = NULL;
- char sep[2] = {_sep, '\0'};
- char **tmp = NULL, **result = NULL;
- size_t result_capacity = 0;
- size_t result_count = 0;
- int r, saved_errno;
- size_t len;
-
- if (!string)
- return calloc(1, sizeof(char *));
-
- len = strlen(string);
- str = alloca(len + 1);
- (void)strlcpy(str, string, len + 1);
-
- for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
- r = lxc_grow_array((void ***)&result, &result_capacity, result_count + 1, 16);
- if (r < 0)
- goto error_out;
-
- result[result_count] = strdup(token);
- if (!result[result_count])
- goto error_out;
-
- result_count++;
- }
-
- /* if we allocated too much, reduce it */
- tmp = realloc(result, (result_count + 1) * sizeof(char *));
- if (!tmp)
- goto error_out;
-
- result = tmp;
-
- /* Make sure we don't return uninitialized memory. */
- if (result_count == 0)
- *result = NULL;
-
- return result;
-
-error_out:
- saved_errno = errno;
- lxc_free_array((void **)result, free);
- errno = saved_errno;
- return NULL;
-}
-
-static bool complete_word(char ***result, char *start, char *end, size_t *cap, size_t *cnt)
-{
- int r;
-
- r = lxc_grow_array((void ***)result, cap, 2 + *cnt, 16);
- if (r < 0)
- return false;
-
- (*result)[*cnt] = strndup(start, end - start);
- if (!(*result)[*cnt])
- return false;
-
- (*cnt)++;
-
- return true;
-}
-
-/*
- * Given a a string 'one two "three four"', split into three words,
- * one, two, and "three four"
- */
-char **lxc_string_split_quoted(char *string)
-{
- char *nextword = string, *p, state;
- char **result = NULL;
- size_t result_capacity = 0;
- size_t result_count = 0;
-
- if (!string || !*string)
- return calloc(1, sizeof(char *));
-
- // TODO I'm *not* handling escaped quote
- state = ' ';
- for (p = string; *p; p++) {
- switch(state) {
- case ' ':
- if (isspace(*p))
- continue;
- else if (*p == '"' || *p == '\'') {
- nextword = p;
- state = *p;
- continue;
- }
- nextword = p;
- state = 'a';
- continue;
- case 'a':
- if (isspace(*p)) {
- complete_word(&result, nextword, p, &result_capacity, &result_count);
- state = ' ';
- continue;
- }
- continue;
- case '"':
- case '\'':
- if (*p == state) {
- complete_word(&result, nextword+1, p, &result_capacity, &result_count);
- state = ' ';
- continue;
- }
- continue;
- }
- }
-
- if (state == 'a')
- complete_word(&result, nextword, p, &result_capacity, &result_count);
-
- return realloc(result, (result_count + 1) * sizeof(char *));
-}
-
-char **lxc_string_split_and_trim(const char *string, char _sep)
-{
- char *token, *str, *saveptr = NULL;
- char sep[2] = { _sep, '\0' };
- char **result = NULL;
- size_t result_capacity = 0;
- size_t result_count = 0;
- int r, saved_errno;
- size_t i = 0;
- size_t len;
-
- if (!string)
- return calloc(1, sizeof(char *));
-
- len = strlen(string);
- str = alloca(len + 1);
- (void)strlcpy(str, string, len + 1);
-
- for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
- while (token[0] == ' ' || token[0] == '\t')
- token++;
-
- i = strlen(token);
- while (i > 0 && (token[i - 1] == ' ' || token[i - 1] == '\t')) {
- token[i - 1] = '\0';
- i--;
- }
-
- r = lxc_grow_array((void ***)&result, &result_capacity, result_count + 1, 16);
- if (r < 0)
- goto error_out;
-
- result[result_count] = strdup(token);
- if (!result[result_count])
- goto error_out;
-
- result_count++;
- }
-
- /* if we allocated too much, reduce it */
- return realloc(result, (result_count + 1) * sizeof(char *));
-
-error_out:
- saved_errno = errno;
- lxc_free_array((void **)result, free);
- errno = saved_errno;
- return NULL;
-}
-
-void lxc_free_array(void **array, lxc_free_fn element_free_fn)
-{
- void **p;
-
- for (p = array; p && *p; p++)
- element_free_fn(*p);
-
- free((void*)array);
-}
-
-int lxc_grow_array(void ***array, size_t *capacity, size_t new_size, size_t capacity_increment)
-{
- size_t new_capacity;
- void **new_array;
-
- /* first time around, catch some trivial mistakes of the user
- * only initializing one of these */
- if (!*array || !*capacity) {
- *array = NULL;
- *capacity = 0;
- }
-
- new_capacity = *capacity;
- while (new_size + 1 > new_capacity)
- new_capacity += capacity_increment;
-
- if (new_capacity != *capacity) {
- /* we have to reallocate */
- new_array = realloc(*array, new_capacity * sizeof(void *));
- if (!new_array)
- return -1;
-
- memset(&new_array[*capacity], 0, (new_capacity - (*capacity)) * sizeof(void *));
- *array = new_array;
- *capacity = new_capacity;
- }
-
- /* array has sufficient elements */
- return 0;
-}
-
-size_t lxc_array_len(void **array)
-{
- void **p;
- size_t result = 0;
-
- for (p = array; p && *p; p++)
- result++;
-
- return result;
-}
-
-int lxc_write_to_file(const char *filename, const void *buf, size_t count,
- bool add_newline, mode_t mode)
-{
- int fd, saved_errno;
- ssize_t ret;
-
- fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, mode);
- if (fd < 0)
- return -1;
-
- ret = lxc_write_nointr(fd, buf, count);
- if (ret < 0)
- goto out_error;
-
- if ((size_t)ret != count)
- goto out_error;
-
- if (add_newline) {
- ret = lxc_write_nointr(fd, "\n", 1);
- if (ret != 1)
- goto out_error;
- }
-
- close(fd);
- return 0;
-
-out_error:
- saved_errno = errno;
- close(fd);
- errno = saved_errno;
- return -1;
-}
-
-int lxc_read_from_file(const char *filename, void *buf, size_t count)
-{
- int fd = -1, saved_errno;
- ssize_t ret;
-
- fd = open(filename, O_RDONLY | O_CLOEXEC);
- if (fd < 0)
- return -1;
-
- if (!buf || !count) {
- char buf2[100];
- size_t count2 = 0;
-
- while ((ret = read(fd, buf2, 100)) > 0)
- count2 += ret;
-
- if (ret >= 0)
- ret = count2;
- } else {
- memset(buf, 0, count);
- ret = read(fd, buf, count);
- }
-
- if (ret < 0)
- SYSERROR("Read %s", filename);
-
- saved_errno = errno;
- close(fd);
- errno = saved_errno;
- return ret;
-}
-
-void **lxc_append_null_to_array(void **array, size_t count)
-{
- void **temp;
-
- /* Append NULL to the array */
- if (count) {
- temp = realloc(array, (count + 1) * sizeof(*array));
- if (!temp) {
- size_t i;
- for (i = 0; i < count; i++)
- free(array[i]);
- free(array);
- return NULL;
- }
-
- array = temp;
- array[count] = NULL;
- }
-
- return array;
-}
-
int randseed(bool srand_it)
{
/*
return hval;
}
-/*
- * Detect whether / is mounted MS_SHARED. The only way I know of to
- * check that is through /proc/self/mountinfo.
- * I'm only checking for /. If the container rootfs or mount location
- * is MS_SHARED, but not '/', then you're out of luck - figuring that
- * out would be too much work to be worth it.
- */
-int detect_shared_rootfs(void)
+bool is_shared_mountpoint(const char *path)
{
- char buf[LXC_LINELEN], *p;
+ char buf[LXC_LINELEN];
FILE *f;
int i;
- char *p2;
+ char *p, *p2;
f = fopen("/proc/self/mountinfo", "r");
if (!f)
continue;
*p2 = '\0';
- if (strcmp(p + 1, "/") == 0) {
- /* This is '/'. Is it shared? */
+ if (strcmp(p + 1, path) == 0) {
+ /* This is the path. Is it shared? */
p = strchr(p2 + 1, ' ');
if (p && strstr(p, "shared:")) {
fclose(f);
- return 1;
+ return true;
}
}
}
fclose(f);
+ return false;
+}
+
+/*
+ * Detect whether / is mounted MS_SHARED. The only way I know of to
+ * check that is through /proc/self/mountinfo.
+ * I'm only checking for /. If the container rootfs or mount location
+ * is MS_SHARED, but not '/', then you're out of luck - figuring that
+ * out would be too much work to be worth it.
+ */
+int detect_shared_rootfs(void)
+{
+ if (is_shared_mountpoint("/"))
+ return 1;
return 0;
}
-bool switch_to_ns(pid_t pid, const char *ns) {
+bool switch_to_ns(pid_t pid, const char *ns)
+{
int fd, ret;
char nspath[MAXPATHLEN];
if (p && strncmp(p, "- rootfs rootfs ", 16) == 0) {
free(line);
fclose(f);
+ INFO("Rootfs is located on ramfs");
return true;
}
}
return false;
}
-char *on_path(const char *cmd, const char *rootfs) {
- char *path = NULL;
- char *entry = NULL;
- char *saveptr = NULL;
+char *on_path(const char *cmd, const char *rootfs)
+{
+ char *entry = NULL, *path = NULL;
char cmdpath[MAXPATHLEN];
int ret;
if (!path)
return NULL;
- entry = strtok_r(path, ":", &saveptr);
- while (entry) {
+ lxc_iterate_parts (entry, path, ":") {
if (rootfs)
- ret = snprintf(cmdpath, MAXPATHLEN, "%s/%s/%s", rootfs, entry, cmd);
+ ret = snprintf(cmdpath, MAXPATHLEN, "%s/%s/%s", rootfs,
+ entry, cmd);
else
ret = snprintf(cmdpath, MAXPATHLEN, "%s/%s", entry, cmd);
-
if (ret < 0 || ret >= MAXPATHLEN)
- goto next_loop;
+ continue;
if (access(cmdpath, X_OK) == 0) {
free(path);
return strdup(cmdpath);
}
-
-next_loop:
- entry = strtok_r(NULL, ":", &saveptr);
}
free(path);
return NULL;
}
-bool file_exists(const char *f)
-{
- struct stat statbuf;
-
- return stat(f, &statbuf) == 0;
-}
-
bool cgns_supported(void)
{
return file_exists("/proc/self/ns/cgroup");
* hopefully bind-mounted in.
* If we are called during container setup, and we get to this point,
* then the init.lxc.static from the host will need to be bind-mounted
- * in. So we return NULL here to indicate that.
- */
- if (rootfs)
- goto out1;
-
- ret = snprintf(retv, PATH_MAX, "/init.lxc.static");
- if (ret < 0 || ret >= PATH_MAX) {
- WARN("Nonsense - name /lxc.init.static too long");
- goto out1;
- }
-
- if (access(retv, X_OK) == 0)
- return retv;
-
-out1:
- free(retv);
- return NULL;
-}
-
-int print_to_file(const char *file, const char *content)
-{
- FILE *f;
- int ret = 0;
-
- f = fopen(file, "w");
- if (!f)
- return -1;
-
- if (fprintf(f, "%s", content) != strlen(content))
- ret = -1;
-
- fclose(f);
- return ret;
-}
+ * in. So we return NULL here to indicate that.
+ */
+ if (rootfs)
+ goto out1;
-int is_dir(const char *path)
-{
- struct stat statbuf;
- int ret;
+ ret = snprintf(retv, PATH_MAX, "/init.lxc.static");
+ if (ret < 0 || ret >= PATH_MAX) {
+ WARN("Nonsense - name /lxc.init.static too long");
+ goto out1;
+ }
- ret = stat(path, &statbuf);
- if (ret == 0 && S_ISDIR(statbuf.st_mode))
- return 1;
+ if (access(retv, X_OK) == 0)
+ return retv;
- return 0;
+out1:
+ free(retv);
+ return NULL;
}
/*
{
char path[MAXPATHLEN];
int link_to_pid, linklen, mypid, ret;
- char link[LXC_NUMSTRLEN64] = {0};
+ char link[INTTYPE_TO_STRLEN(pid_t)] = {0};
ret = snprintf(path, MAXPATHLEN, "%s/proc/self", rootfs);
if (ret < 0 || ret >= MAXPATHLEN) {
return -1;
}
- linklen = readlink(path, link, LXC_NUMSTRLEN64);
+ linklen = readlink(path, link, sizeof(link));
ret = snprintf(path, MAXPATHLEN, "%s/proc", rootfs);
if (ret < 0 || ret >= MAXPATHLEN) {
return -1;
goto domount;
- } else if (linklen >= LXC_NUMSTRLEN64) {
+ } else if (linklen >= sizeof(link)) {
link[linklen - 1] = '\0';
ERROR("readlink returned truncated content: \"%s\"", link);
return -1;
return ret;
}
-/*
- * Return the number of lines in file @fn, or -1 on error
- */
-int lxc_count_file_lines(const char *fn)
-{
- FILE *f;
- char *line = NULL;
- size_t sz = 0;
- int n = 0;
-
- f = fopen_cloexec(fn, "r");
- if (!f)
- return -1;
-
- while (getline(&line, &sz, f) != -1) {
- n++;
- }
-
- free(line);
- fclose(f);
- return n;
-}
-
/* Check whether a signal is blocked by a process. */
/* /proc/pid-to-str/status\0 = (5 + 21 + 7 + 1) */
-#define __PROC_STATUS_LEN (6 + (LXC_NUMSTRLEN64) + 7 + 1)
+#define __PROC_STATUS_LEN (6 + INTTYPE_TO_STRLEN(pid_t) + 7 + 1)
bool task_blocks_signal(pid_t pid, int signal)
{
int ret;
return bret;
}
-static int lxc_append_null_to_list(void ***list)
-{
- int newentry = 0;
- void **tmp;
-
- if (*list)
- for (; (*list)[newentry]; newentry++) {
- ;
- }
-
- tmp = realloc(*list, (newentry + 2) * sizeof(void **));
- if (!tmp)
- return -1;
-
- *list = tmp;
- (*list)[newentry + 1] = NULL;
-
- return newentry;
-}
-
-int lxc_append_string(char ***list, char *entry)
-{
- char *copy;
- int newentry;
-
- newentry = lxc_append_null_to_list((void ***)list);
- if (newentry < 0)
- return -1;
-
- copy = strdup(entry);
- if (!copy)
- return -1;
-
- (*list)[newentry] = copy;
-
- return 0;
-}
-
int lxc_preserve_ns(const int pid, const char *ns)
{
int ret;
ret = snprintf(path, __NS_PATH_LEN, "/proc/%d/ns%s%s", pid,
!ns || strcmp(ns, "") == 0 ? "" : "/",
!ns || strcmp(ns, "") == 0 ? "" : ns);
- errno = EFBIG;
- if (ret < 0 || (size_t)ret >= __NS_PATH_LEN)
- return -EFBIG;
+ if (ret < 0 || (size_t)ret >= __NS_PATH_LEN) {
+ errno = EFBIG;
+ return -1;
+ }
return open(path, O_RDONLY | O_CLOEXEC);
}
-int lxc_safe_uint(const char *numstr, unsigned int *converted)
-{
- char *err = NULL;
- unsigned long int uli;
-
- while (isspace(*numstr))
- numstr++;
-
- if (*numstr == '-')
- return -EINVAL;
-
- errno = 0;
- uli = strtoul(numstr, &err, 0);
- if (errno == ERANGE && uli == ULONG_MAX)
- return -ERANGE;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- if (uli > UINT_MAX)
- return -ERANGE;
-
- *converted = (unsigned int)uli;
- return 0;
-}
-
-int lxc_safe_ulong(const char *numstr, unsigned long *converted)
-{
- char *err = NULL;
- unsigned long int uli;
-
- while (isspace(*numstr))
- numstr++;
-
- if (*numstr == '-')
- return -EINVAL;
-
- errno = 0;
- uli = strtoul(numstr, &err, 0);
- if (errno == ERANGE && uli == ULONG_MAX)
- return -ERANGE;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- *converted = uli;
- return 0;
-}
-
-int lxc_safe_uint64(const char *numstr, uint64_t *converted, int base)
-{
- char *err = NULL;
- uint64_t u;
-
- while (isspace(*numstr))
- numstr++;
-
- if (*numstr == '-')
- return -EINVAL;
-
- errno = 0;
- u = strtoull(numstr, &err, base);
- if (errno == ERANGE && u == ULLONG_MAX)
- return -ERANGE;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- *converted = u;
- return 0;
-}
-
-int lxc_safe_int(const char *numstr, int *converted)
-{
- char *err = NULL;
- signed long int sli;
-
- errno = 0;
- sli = strtol(numstr, &err, 0);
- if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))
- return -ERANGE;
-
- if (errno != 0 && sli == 0)
- return -EINVAL;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- if (sli > INT_MAX || sli < INT_MIN)
- return -ERANGE;
-
- *converted = (int)sli;
- return 0;
-}
-
-int lxc_safe_long(const char *numstr, long int *converted)
-{
- char *err = NULL;
- signed long int sli;
-
- errno = 0;
- sli = strtol(numstr, &err, 0);
- if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))
- return -ERANGE;
-
- if (errno != 0 && sli == 0)
- return -EINVAL;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- *converted = sli;
- return 0;
-}
-
-int lxc_safe_long_long(const char *numstr, long long int *converted)
-{
- char *err = NULL;
- signed long long int sli;
-
- errno = 0;
- sli = strtoll(numstr, &err, 0);
- if (errno == ERANGE && (sli == LLONG_MAX || sli == LLONG_MIN))
- return -ERANGE;
-
- if (errno != 0 && sli == 0)
- return -EINVAL;
-
- if (err == numstr || *err != '\0')
- return -EINVAL;
-
- *converted = sli;
- return 0;
-}
-
int lxc_switch_uid_gid(uid_t uid, gid_t gid)
{
if (setgid(gid) < 0) {
close(pipefd[1]);
if (buf && buf_size > 0) {
- bytes = read(pipefd[0], buf, buf_size - 1);
+ bytes = lxc_read_nointr(pipefd[0], buf, buf_size - 1);
if (bytes > 0)
buf[bytes - 1] = '\0';
}
return fret;
}
-char *must_make_path(const char *first, ...)
-{
- va_list args;
- char *cur, *dest;
- size_t full_len = strlen(first);
- size_t buf_len;
-
- dest = must_copy_string(first);
-
- va_start(args, first);
- while ((cur = va_arg(args, char *)) != NULL) {
- full_len += strlen(cur);
- if (cur[0] != '/')
- full_len++;
-
- buf_len = full_len + 1;
- dest = must_realloc(dest, buf_len);
-
- if (cur[0] != '/')
- (void)strlcat(dest, "/", buf_len);
- (void)strlcat(dest, cur, buf_len);
- }
- va_end(args);
-
- return dest;
-}
-
-char *must_append_path(char *first, ...)
-{
- char *cur;
- size_t full_len;
- va_list args;
- char *dest = first;
- size_t buf_len;
-
- full_len = strlen(first);
- va_start(args, first);
- while ((cur = va_arg(args, char *)) != NULL) {
- full_len += strlen(cur);
- if (cur[0] != '/')
- full_len++;
-
- buf_len = full_len + 1;
- dest = must_realloc(dest, buf_len);
-
- if (cur[0] != '/')
- (void)strlcat(dest, "/", buf_len);
- (void)strlcat(dest, cur, buf_len);
- }
- va_end(args);
-
- return dest;
-}
-
-char *must_copy_string(const char *entry)
-{
- char *ret;
-
- if (!entry)
- return NULL;
-
- do {
- ret = strdup(entry);
- } while (!ret);
-
- return ret;
-}
-
-void *must_realloc(void *orig, size_t sz)
-{
- void *ret;
-
- do {
- ret = realloc(orig, sz);
- } while (!ret);
-
- return ret;
-}
-
-bool is_fs_type(const struct statfs *fs, fs_type_magic magic_val)
-{
- return (fs->f_type == (fs_type_magic)magic_val);
-}
-
-bool has_fs_type(const char *path, fs_type_magic magic_val)
-{
- bool has_type;
- int ret;
- struct statfs sb;
-
- ret = statfs(path, &sb);
- if (ret < 0)
- return false;
-
- has_type = is_fs_type(&sb, magic_val);
- if (!has_type && magic_val == RAMFS_MAGIC)
- WARN("When the ramfs it a tmpfs statfs() might report tmpfs");
-
- return has_type;
-}
-
bool lxc_nic_exists(char *nic)
{
#define __LXC_SYS_CLASS_NET_LEN 15 + IFNAMSIZ + 1
return true;
}
-int lxc_make_tmpfile(char *template, bool rm)
-{
- int fd, ret;
- mode_t msk;
-
- msk = umask(0022);
- fd = mkstemp(template);
- umask(msk);
- if (fd < 0)
- return -1;
-
- if (!rm)
- return fd;
-
- ret = unlink(template);
- if (ret < 0) {
- close(fd);
- return -1;
- }
-
- return fd;
-}
-
-int parse_byte_size_string(const char *s, int64_t *converted)
-{
- int ret, suffix_len;
- long long int conv;
- int64_t mltpl, overflow;
- char *end;
- char dup[LXC_NUMSTRLEN64 + 2];
- char suffix[3] = {0};
-
- if (!s || !strcmp(s, ""))
- return -EINVAL;
-
- end = stpncpy(dup, s, sizeof(dup) - 1);
- if (*end != '\0')
- return -EINVAL;
-
- if (isdigit(*(end - 1)))
- suffix_len = 0;
- else if (isalpha(*(end - 1)))
- suffix_len = 1;
- else
- return -EINVAL;
-
- if (suffix_len > 0 && (end - 2) == dup && !isdigit(*(end - 2)))
- return -EINVAL;
-
- if (suffix_len > 0 && isalpha(*(end - 2)))
- suffix_len++;
-
- if (suffix_len > 0) {
- memcpy(suffix, end - suffix_len, suffix_len);
- *(suffix + suffix_len) = '\0';
- *(end - suffix_len) = '\0';
- }
- dup[lxc_char_right_gc(dup, strlen(dup))] = '\0';
-
- ret = lxc_safe_long_long(dup, &conv);
- if (ret < 0)
- return -ret;
-
- if (suffix_len != 2) {
- *converted = conv;
- return 0;
- }
-
- if (strcasecmp(suffix, "KB") == 0)
- mltpl = 1024;
- else if (strcasecmp(suffix, "MB") == 0)
- mltpl = 1024 * 1024;
- else if (strcasecmp(suffix, "GB") == 0)
- mltpl = 1024 * 1024 * 1024;
- else
- return -EINVAL;
-
- overflow = conv * mltpl;
- if (conv != 0 && (overflow / conv) != mltpl)
- return -ERANGE;
-
- *converted = overflow;
- return 0;
-}
-
uint64_t lxc_find_next_power2(uint64_t n)
{
/* 0 is not valid input. We return 0 to the caller since 0 is not a
int ret;
pid_t ppid;
- ret = prctl(PR_SET_PDEATHSIG, signal, 0, 0, 0);
+ ret = prctl(PR_SET_PDEATHSIG, prctl_arg(signal), prctl_arg(0),
+ prctl_arg(0), prctl_arg(0));
/* Check whether we have been orphaned. */
ppid = (pid_t)syscall(SYS_getppid);
return 0;
}
-void remove_trailing_newlines(char *l)
-{
- char *p = l;
-
- while (*p)
- p++;
-
- while (--p >= l && *p == '\n')
- *p = '\0';
-}
-
int fd_cloexec(int fd, bool cloexec)
{
int oflags, nflags;
return 0;
}
+
+int recursive_destroy(char *dirname)
+{
+ int ret;
+ struct dirent *direntp;
+ DIR *dir;
+ int r = 0;
+
+ dir = opendir(dirname);
+ if (!dir)
+ return -1;
+
+ while ((direntp = readdir(dir))) {
+ char *pathname;
+ struct stat mystat;
+
+ if (!strcmp(direntp->d_name, ".") ||
+ !strcmp(direntp->d_name, ".."))
+ continue;
+
+ pathname = must_make_path(dirname, direntp->d_name, NULL);
+
+ ret = lstat(pathname, &mystat);
+ if (ret < 0) {
+ if (!r)
+ WARN("Failed to stat \"%s\"", pathname);
+
+ r = -1;
+ goto next;
+ }
+
+ if (!S_ISDIR(mystat.st_mode))
+ goto next;
+
+ ret = recursive_destroy(pathname);
+ if (ret < 0)
+ r = -1;
+
+ next:
+ free(pathname);
+ }
+
+ ret = rmdir(dirname);
+ if (ret < 0) {
+ if (!r)
+ SYSWARN("Failed to delete \"%s\"", dirname);
+
+ r = -1;
+ }
+
+ ret = closedir(dir);
+ if (ret < 0) {
+ if (!r)
+ SYSWARN("Failed to delete \"%s\"", dirname);
+
+ r = -1;
+ }
+
+ return r;
+}
projects / mirror_lxc.git / blobdiff