X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fshared%2Fpath-util.c;h=00d2d44993d3711adfc2b244e994360d1f2a8912;hp=8e108db53173f1c39ef1ae2965c7081031ee6fce;hb=2695c5c44e028d1bc07404baf3357e5a6017fc57;hpb=c9d954b27ee125c3c90a6d2951c62eec4abb160b diff --git a/src/shared/path-util.c b/src/shared/path-util.c index 8e108db53..00d2d4499 100644 --- a/src/shared/path-util.c +++ b/src/shared/path-util.c @@ -45,18 +45,6 @@ bool is_path(const char *p) { return !!strchr(p, '/'); } -char *path_get_file_name(const char *p) { - char *r; - - assert(p); - - r = strrchr(p, '/'); - if (r) - 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; @@ -141,7 +129,92 @@ char *path_make_absolute_cwd(const char *p) { if (!cwd) return NULL; - return path_make_absolute(p, cwd); + return strjoin(cwd, "/", p, NULL); +} + +int path_make_relative(const char *from_dir, const char *to_path, char **_r) { + char *r, *p; + unsigned n_parents; + + assert(from_dir); + assert(to_path); + assert(_r); + + /* Strips the common part, and adds ".." elements as necessary. */ + + if (!path_is_absolute(from_dir)) + return -EINVAL; + + if (!path_is_absolute(to_path)) + return -EINVAL; + + /* Skip the common part. */ + for (;;) { + size_t a; + size_t b; + + from_dir += strspn(from_dir, "/"); + to_path += strspn(to_path, "/"); + + if (!*from_dir) { + if (!*to_path) + /* from_dir equals to_path. */ + r = strdup("."); + else + /* from_dir is a parent directory of to_path. */ + r = strdup(to_path); + + if (!r) + return -ENOMEM; + + path_kill_slashes(r); + + *_r = r; + return 0; + } + + if (!*to_path) + break; + + a = strcspn(from_dir, "/"); + b = strcspn(to_path, "/"); + + if (a != b) + break; + + if (memcmp(from_dir, to_path, a) != 0) + break; + + from_dir += a; + to_path += b; + } + + /* If we're here, then "from_dir" has one or more elements that need to + * be replaced with "..". */ + + /* Count the number of necessary ".." elements. */ + for (n_parents = 0;;) { + from_dir += strspn(from_dir, "/"); + + if (!*from_dir) + break; + + from_dir += strcspn(from_dir, "/"); + n_parents++; + } + + r = malloc(n_parents * 3 + strlen(to_path) + 1); + if (!r) + return -ENOMEM; + + for (p = r; n_parents > 0; n_parents--, p += 3) + memcpy(p, "../", 3); + + strcpy(p, to_path); + path_kill_slashes(r); + + *_r = r; + return 0; } char **path_strv_make_absolute_cwd(char **l) { @@ -165,7 +238,7 @@ char **path_strv_make_absolute_cwd(char **l) { return l; } -char **path_strv_canonicalize(char **l) { +char **path_strv_resolve(char **l, const char *prefix) { char **s; unsigned k = 0; bool enomem = false; @@ -179,28 +252,64 @@ char **path_strv_canonicalize(char **l) { STRV_FOREACH(s, l) { char *t, *u; + _cleanup_free_ char *orig = NULL; - t = path_make_absolute_cwd(*s); - free(*s); - *s = NULL; - - if (!t) { - enomem = true; + if (!path_is_absolute(*s)) { + free(*s); continue; } + if (prefix) { + orig = *s; + t = strappend(prefix, orig); + if (!t) { + enomem = true; + continue; + } + } else + t = *s; + errno = 0; u = canonicalize_file_name(t); if (!u) { - if (errno == ENOENT) - u = t; - else { + if (errno == ENOENT) { + if (prefix) { + u = orig; + orig = NULL; + free(t); + } else + u = t; + } else { free(t); - if (errno == ENOMEM || !errno) + if (errno == ENOMEM || errno == 0) enomem = true; continue; } + } else if (prefix) { + char *x; + + free(t); + x = path_startswith(u, prefix); + if (x) { + /* restore the slash if it was lost */ + if (!startswith(x, "/")) + *(--x) = '/'; + + t = strdup(x); + free(u); + if (!t) { + enomem = true; + continue; + } + u = t; + } else { + /* canonicalized path goes outside of + * prefix, keep the original path instead */ + free(u); + u = orig; + orig = NULL; + } } else free(t); @@ -215,11 +324,12 @@ char **path_strv_canonicalize(char **l) { return l; } -char **path_strv_canonicalize_uniq(char **l) { +char **path_strv_resolve_uniq(char **l, const char *prefix) { + if (strv_isempty(l)) return l; - if (!path_strv_canonicalize(l)) + if (!path_strv_resolve(l, prefix)) return NULL; return strv_uniq(l); @@ -326,12 +436,30 @@ bool path_equal(const char *a, const char *b) { } } +char* path_join(const char *root, const char *path, const char *rest) { + assert(path); + + if (!isempty(root)) + return strjoin(root, endswith(root, "/") ? "" : "/", + path[0] == '/' ? path+1 : path, + rest ? (endswith(path, "/") ? "" : "/") : NULL, + rest && rest[0] == '/' ? rest+1 : rest, + NULL); + else + return strjoin(path, + rest ? (endswith(path, "/") ? "" : "/") : NULL, + rest && rest[0] == '/' ? rest+1 : rest, + NULL); +} + int path_is_mount_point(const char *t, bool allow_symlink) { - char *parent; - int r; - struct file_handle *h; - int mount_id, mount_id_parent; + + union file_handle_union h = FILE_HANDLE_INIT; + int mount_id = -1, mount_id_parent = -1; + _cleanup_free_ char *parent = NULL; struct stat a, b; + int r; + bool nosupp = false; /* We are not actually interested in the file handles, but * name_to_handle_at() also passes us the mount ID, hence use @@ -340,42 +468,45 @@ int path_is_mount_point(const char *t, bool allow_symlink) { if (path_equal(t, "/")) return 1; - h = alloca(MAX_HANDLE_SZ); - h->handle_bytes = MAX_HANDLE_SZ; - - r = name_to_handle_at(AT_FDCWD, t, h, &mount_id, allow_symlink ? AT_SYMLINK_FOLLOW : 0); + r = name_to_handle_at(AT_FDCWD, t, &h.handle, &mount_id, allow_symlink ? AT_SYMLINK_FOLLOW : 0); if (r < 0) { - if (errno == ENOSYS || errno == ENOTSUP) + if (errno == ENOSYS) + /* This kernel does not support name_to_handle_at() + * fall back to the traditional stat() logic. */ + goto fallback; + else if (errno == EOPNOTSUPP) /* This kernel or file system does not support * name_to_handle_at(), hence fallback to the * traditional stat() logic */ - goto fallback; - - if (errno == ENOENT) + nosupp = true; + else if (errno == ENOENT) return 0; - - return -errno; + else + return -errno; } r = path_get_parent(t, &parent); if (r < 0) return r; - h->handle_bytes = MAX_HANDLE_SZ; - r = name_to_handle_at(AT_FDCWD, parent, h, &mount_id_parent, 0); - free(parent); - - 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; + h.handle.handle_bytes = MAX_HANDLE_SZ; + r = name_to_handle_at(AT_FDCWD, parent, &h.handle, &mount_id_parent, AT_SYMLINK_FOLLOW); + if (r < 0) + if (errno == EOPNOTSUPP) + if (nosupp) + /* Neither parent nor child do name_to_handle_at()? + We have no choice but to fall back. */ + goto fallback; + else + /* The parent can't do name_to_handle_at() but + * the directory we are interested in can? + * Or the other way around? + * If so, it must be a mount point. */ + return 1; + else + return -errno; + else + return mount_id != mount_id_parent; fallback: if (allow_symlink) @@ -390,13 +521,14 @@ fallback: return -errno; } + free(parent); + parent = NULL; + r = path_get_parent(t, &parent); if (r < 0) return r; - r = lstat(parent, &b); - free(parent); - + r = stat(parent, &b); if (r < 0) return -errno; @@ -411,38 +543,57 @@ int path_is_read_only_fs(const char *path) { if (statvfs(path, &st) < 0) return -errno; - return !!(st.f_flag & ST_RDONLY); + if (st.f_flag & ST_RDONLY) + return true; + + /* On NFS, statvfs() might not reflect whether we can actually + * write to the remote share. Let's try again with + * access(W_OK) which is more reliable, at least sometimes. */ + if (access(path, W_OK) < 0 && errno == EROFS) + return true; + + return false; } 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 */ + /* We use /usr/lib/os-release as flag file if something is an OS */ + p = strappenda(path, "/usr/lib/os-release"); + r = access(p, F_OK); + if (r >= 0) + return 1; + + /* Also check for the old location in /etc, just in case. */ p = strappenda(path, "/etc/os-release"); r = access(p, F_OK); - return r < 0 ? 0 : 1; + return r >= 0; } -int find_binary(const char *name, char **filename) { +int find_binary(const char *name, bool local, char **filename) { assert(name); - if (strchr(name, '/')) { - char *p; - if (path_is_absolute(name)) - p = strdup(name); - else + if (is_path(name)) { + if (local && access(name, X_OK) < 0) + return -errno; + + if (filename) { + char *p; + p = path_make_absolute_cwd(name); - if (!p) - return -ENOMEM; + if (!p) + return -ENOMEM; + + *filename = p; + } - *filename = p; return 0; } else { const char *path; - char *state, *w; + const char *word, *state; size_t l; /** @@ -453,19 +604,19 @@ int find_binary(const char *name, char **filename) { if (!path) path = DEFAULT_PATH; - FOREACH_WORD_SEPARATOR(w, l, path, ":", state) { - char *p; + FOREACH_WORD_SEPARATOR(word, l, path, ":", state) { + _cleanup_free_ char *p = NULL; - if (asprintf(&p, "%.*s/%s", l, w, name) < 0) + if (asprintf(&p, "%.*s/%s", (int) l, word, name) < 0) return -ENOMEM; - if (access(p, X_OK) < 0) { - free(p); + if (access(p, X_OK) < 0) continue; - } - path_kill_slashes(p); - *filename = p; + if (filename) { + *filename = path_kill_slashes(p); + p = NULL; + } return 0; } @@ -473,3 +624,62 @@ int find_binary(const char *name, char **filename) { 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; +} + +int fsck_exists(const char *fstype) { + _cleanup_free_ char *p = NULL, *d = NULL; + const char *checker; + int r; + + checker = strappenda("fsck.", fstype); + + r = find_binary(checker, true, &p); + if (r < 0) + return r; + + /* An fsck that is linked to /bin/true is a non-existent + * fsck */ + + r = readlink_malloc(p, &d); + if (r >= 0 && + (path_equal(d, "/bin/true") || + path_equal(d, "/usr/bin/true") || + path_equal(d, "/dev/null"))) + return -ENOENT; + + return 0; +}