return !!strchr(p, '/');
}
-char *path_get_file_name(const char *p) {
- char *r;
-
- assert(p);
-
- if ((r = strrchr(p, '/')))
- return r + 1;
-
- return (char*) p;
-}
-
int path_get_parent(const char *path, char **_r) {
const char *e, *a = NULL, *b = NULL, *p;
char *r;
char **l;
assert(p);
- if (!(l = strv_split(p, ":")))
+ l = strv_split(p, ":");
+ if (!l)
return NULL;
if (!path_strv_make_absolute_cwd(l)) {
}
char *path_make_absolute_cwd(const char *p) {
- char *cwd, *r;
+ _cleanup_free_ char *cwd = NULL;
assert(p);
if (path_is_absolute(p))
return strdup(p);
- if (!(cwd = get_current_dir_name()))
+ cwd = get_current_dir_name();
+ if (!cwd)
return NULL;
- r = path_make_absolute(p, cwd);
- free(cwd);
-
- return r;
+ return path_make_absolute(p, cwd);
}
char **path_strv_make_absolute_cwd(char **l) {
STRV_FOREACH(s, l) {
char *t;
- if (!(t = path_make_absolute_cwd(*s)))
+ t = path_make_absolute_cwd(*s);
+ if (!t)
return NULL;
free(*s);
return l;
}
-char **path_strv_canonicalize(char **l) {
+char **path_strv_canonicalize_absolute(char **l, const char *prefix) {
char **s;
unsigned k = 0;
bool enomem = false;
STRV_FOREACH(s, l) {
char *t, *u;
- t = path_make_absolute_cwd(*s);
- free(*s);
-
- if (!t) {
- enomem = true;
+ if (!path_is_absolute(*s))
continue;
+
+ if (prefix) {
+ t = strappend(prefix, *s);
+ free(*s);
+ *s = NULL;
+
+ if (!t) {
+ enomem = true;
+ continue;
+ }
+ } else {
+ t = *s;
+ *s = NULL;
}
errno = 0;
u = canonicalize_file_name(t);
- free(t);
-
if (!u) {
- if (errno == ENOMEM || !errno)
- enomem = true;
-
- continue;
- }
+ if (errno == ENOENT)
+ u = t;
+ else {
+ free(t);
+ if (errno == ENOMEM || errno == 0)
+ enomem = true;
+
+ continue;
+ }
+ } else
+ free(t);
l[k++] = u;
}
return l;
}
-char **path_strv_remove_empty(char **l) {
- char **f, **t;
-
- if (!l)
- return NULL;
-
- for (f = t = l; *f; f++) {
+char **path_strv_canonicalize_absolute_uniq(char **l, const char *prefix) {
- if (dir_is_empty(*f) > 0) {
- free(*f);
- continue;
- }
+ if (strv_isempty(l))
+ return l;
- *(t++) = *f;
- }
+ if (!path_strv_canonicalize_absolute(l, prefix))
+ return NULL;
- *t = NULL;
- return l;
+ return strv_uniq(l);
}
char *path_kill_slashes(char *path) {
return path;
}
-bool path_startswith(const char *path, const char *prefix) {
+char* path_startswith(const char *path, const char *prefix) {
assert(path);
assert(prefix);
if ((path[0] == '/') != (prefix[0] == '/'))
- return false;
+ return NULL;
for (;;) {
size_t a, b;
prefix += strspn(prefix, "/");
if (*prefix == 0)
- return true;
+ return (char*) path;
if (*path == 0)
- return false;
+ return NULL;
a = strcspn(path, "/");
b = strcspn(prefix, "/");
if (a != b)
- return false;
+ return NULL;
if (memcmp(path, prefix, a) != 0)
- return false;
+ return NULL;
path += a;
prefix += b;
int r;
struct file_handle *h;
int mount_id, mount_id_parent;
+ struct stat a, b;
/* We are not actually interested in the file handles, but
* name_to_handle_at() also passes us the mount ID, hence use
r = name_to_handle_at(AT_FDCWD, t, h, &mount_id, allow_symlink ? AT_SYMLINK_FOLLOW : 0);
if (r < 0) {
+ if (errno == ENOSYS || errno == ENOTSUP)
+ /* This kernel or file system does not support
+ * name_to_handle_at(), hence fallback to the
+ * traditional stat() logic */
+ goto fallback;
+
if (errno == ENOENT)
return 0;
r = name_to_handle_at(AT_FDCWD, parent, h, &mount_id_parent, 0);
free(parent);
- if (r < 0)
- return -errno;
+ if (r < 0) {
+ /* The parent can't do name_to_handle_at() but the
+ * directory we are interested in can? If so, it must
+ * be a mount point */
+ if (errno == ENOTSUP)
+ return 1;
+ return -errno;
+ }
return mount_id != mount_id_parent;
+
+fallback:
+ if (allow_symlink)
+ r = stat(t, &a);
+ else
+ r = lstat(t, &a);
+
+ if (r < 0) {
+ if (errno == ENOENT)
+ return 0;
+
+ return -errno;
+ }
+
+ r = path_get_parent(t, &parent);
+ if (r < 0)
+ return r;
+
+ r = lstat(parent, &b);
+ free(parent);
+
+ if (r < 0)
+ return -errno;
+
+ return a.st_dev != b.st_dev;
}
int path_is_read_only_fs(const char *path) {
return !!(st.f_flag & ST_RDONLY);
}
+
+int path_is_os_tree(const char *path) {
+ char *p;
+ int r;
+
+ /* We use /etc/os-release as flag file if something is an OS */
+
+ p = strappenda(path, "/etc/os-release");
+ r = access(p, F_OK);
+
+ return r < 0 ? 0 : 1;
+}
+
+int find_binary(const char *name, char **filename) {
+ assert(name);
+ assert(filename);
+
+ if (strchr(name, '/')) {
+ char *p;
+
+ if (path_is_absolute(name))
+ p = strdup(name);
+ else
+ p = path_make_absolute_cwd(name);
+ if (!p)
+ return -ENOMEM;
+
+ *filename = p;
+ return 0;
+ } else {
+ const char *path;
+ char *state, *w;
+ size_t l;
+
+ /**
+ * Plain getenv, not secure_getenv, because we want
+ * to actually allow the user to pick the binary.
+ */
+ path = getenv("PATH");
+ if (!path)
+ path = DEFAULT_PATH;
+
+ FOREACH_WORD_SEPARATOR(w, l, path, ":", state) {
+ char *p;
+
+ if (asprintf(&p, "%.*s/%s", (int) l, w, name) < 0)
+ return -ENOMEM;
+
+ if (access(p, X_OK) < 0) {
+ free(p);
+ continue;
+ }
+
+ path_kill_slashes(p);
+ *filename = p;
+
+ return 0;
+ }
+
+ return -ENOENT;
+ }
+}
+
+bool paths_check_timestamp(const char* const* paths, usec_t *timestamp, bool update) {
+ bool changed = false;
+ const char* const* i;
+
+ assert(timestamp);
+
+ if (paths == NULL)
+ return false;
+
+ STRV_FOREACH(i, paths) {
+ struct stat stats;
+ usec_t u;
+
+ if (stat(*i, &stats) < 0)
+ continue;
+
+ u = timespec_load(&stats.st_mtim);
+
+ /* first check */
+ if (*timestamp >= u)
+ continue;
+
+ log_debug("timestamp of '%s' changed", *i);
+
+ /* update timestamp */
+ if (update) {
+ *timestamp = u;
+ changed = true;
+ } else
+ return true;
+ }
+
+ return changed;
+}
~ianmdlvl / elogind.git / blobdiff