/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- * * Copyright (C) 2014,2015 Colin Walters . * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include "config.h" #include #include #include #include static unsigned char struct_stat_to_dt (struct stat *stbuf) { if (S_ISDIR (stbuf->st_mode)) return DT_DIR; if (S_ISREG (stbuf->st_mode)) return DT_REG; if (S_ISCHR (stbuf->st_mode)) return DT_CHR; if (S_ISBLK (stbuf->st_mode)) return DT_BLK; if (S_ISFIFO (stbuf->st_mode)) return DT_FIFO; if (S_ISLNK (stbuf->st_mode)) return DT_LNK; if (S_ISSOCK (stbuf->st_mode)) return DT_SOCK; return DT_UNKNOWN; } static gboolean glnx_shutil_rm_rf_children (GLnxDirFdIterator *dfd_iter, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; struct dirent *dent; while (TRUE) { if (!glnx_dirfd_iterator_next_dent (dfd_iter, &dent, cancellable, error)) goto out; if (dent == NULL) break; if (dent->d_type == DT_UNKNOWN) { struct stat stbuf; if (fstatat (dfd_iter->fd, dent->d_name, &stbuf, AT_SYMLINK_NOFOLLOW) == -1) { if (errno == ENOENT) continue; else { glnx_set_error_from_errno (error); goto out; } } dent->d_type = struct_stat_to_dt (&stbuf); /* Assume unknown types are just treated like regular files */ if (dent->d_type == DT_UNKNOWN) dent->d_type = DT_REG; } if (dent->d_type == DT_DIR) { g_auto(GLnxDirFdIterator) child_dfd_iter = { 0, }; if (!glnx_dirfd_iterator_init_at (dfd_iter->fd, dent->d_name, FALSE, &child_dfd_iter, error)) goto out; if (!glnx_shutil_rm_rf_children (&child_dfd_iter, cancellable, error)) goto out; if (unlinkat (dfd_iter->fd, dent->d_name, AT_REMOVEDIR) == -1) { glnx_set_error_from_errno (error); goto out; } } else { if (unlinkat (dfd_iter->fd, dent->d_name, 0) == -1) { if (errno != ENOENT) { glnx_set_error_from_errno (error); goto out; } } } } ret = TRUE; out: return ret; } /** * glnx_shutil_rm_rf_at: * @dfd: A directory file descriptor, or `AT_FDCWD` or `-1` for current * @path: Path * @cancellable: Cancellable * @error: Error * * Recursively delete the filename referenced by the combination of * the directory fd @dfd and @path; it may be a file or directory. No * error is thrown if @path does not exist. */ gboolean glnx_shutil_rm_rf_at (int dfd, const char *path, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; glnx_fd_close int target_dfd = -1; g_auto(GLnxDirFdIterator) dfd_iter = { 0, }; dfd = glnx_dirfd_canonicalize (dfd); /* With O_NOFOLLOW first */ target_dfd = openat (dfd, path, O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW); if (target_dfd == -1) { int errsv = errno; if (errsv == ENOENT) { ; } else if (errsv == ENOTDIR || errsv == ELOOP) { if (unlinkat (dfd, path, 0) != 0) { glnx_set_error_from_errno (error); goto out; } } else { glnx_set_error_from_errno (error); goto out; } } else { if (!glnx_dirfd_iterator_init_take_fd (target_dfd, &dfd_iter, error)) goto out; target_dfd = -1; if (!glnx_shutil_rm_rf_children (&dfd_iter, cancellable, error)) goto out; if (unlinkat (dfd, path, AT_REMOVEDIR) == -1) { int errsv = errno; if (errsv != ENOENT) { glnx_set_error_from_errno (error); goto out; } } } ret = TRUE; out: return ret; } static gboolean mkdir_p_at_internal (int dfd, char *path, int mode, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gboolean did_recurse = FALSE; if (g_cancellable_set_error_if_cancelled (cancellable, error)) goto out; again: if (mkdirat (dfd, path, mode) == -1) { if (errno == ENOENT) { char *lastslash; g_assert (!did_recurse); lastslash = strrchr (path, '/'); g_assert (lastslash != NULL); /* Note we can mutate the buffer as we dup'd it */ *lastslash = '\0'; if (!glnx_shutil_mkdir_p_at (dfd, path, mode, cancellable, error)) goto out; /* Now restore it for another mkdir attempt */ *lastslash = '/'; did_recurse = TRUE; goto again; } else if (errno == EEXIST) { /* Fall through; it may not have been a directory, * but we'll find that out on the next call up. */ } else { glnx_set_error_from_errno (error); goto out; } } ret = TRUE; out: return ret; } /** * glnx_shutil_mkdir_p_at: * @dfd: Directory fd * @path: Directory path to be created * @mode: Mode for newly created directories * @cancellable: Cancellable * @error: Error * * Similar to g_mkdir_with_parents(), except operates relative to the * directory fd @dfd. */ gboolean glnx_shutil_mkdir_p_at (int dfd, const char *path, int mode, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; struct stat stbuf; char *buf; /* Fast path stat to see whether it already exists */ if (fstatat (dfd, path, &stbuf, AT_SYMLINK_NOFOLLOW) == 0) { if (S_ISDIR (stbuf.st_mode)) { ret = TRUE; goto out; } } buf = strdupa (path); if (!mkdir_p_at_internal (dfd, buf, mode, cancellable, error)) goto out; ret = TRUE; out: return ret; }