lib/mkdir-p.c

   1 /* mkdir-p.c -- Ensure that a directory and its parents exist.
   2
   3    Copyright (C) 1990, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* Written by Paul Eggert, David MacKenzie, and Jim Meyering.  */
  21
  22 #include <config.h>
  23
  24 #include "mkdir-p.h"
  25
  26 #include <errno.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 #include "gettext.h"
  31 #define _(msgid) gettext (msgid)
  32
  33 #include "dirchownmod.h"
  34 #include "dirname.h"
  35 #include "error.h"
  36 #include "quote.h"
  37 #include "mkancesdirs.h"
  38 #include "savewd.h"
  39
  40 #ifndef HAVE_FCHMOD
  41 # define HAVE_FCHMOD false
  42 #endif
  43
  44 /* Ensure that the directory DIR exists.
  45
  46    WD is the working directory, as in savewd.c.
  47
  48    If MAKE_ANCESTOR is not null, create any ancestor directories that
  49    don't already exist, by invoking MAKE_ANCESTOR (DIR, ANCESTOR, OPTIONS).
  50    This function should return zero if successful, -1 (setting errno)
  51    otherwise.  In this case, DIR may be modified by storing '\0' bytes
  52    into it, to access the ancestor directories, and this modification
  53    is retained on return if the ancestor directories could not be
  54    created.
  55
  56    Create DIR as a new directory with using mkdir with permissions
  57    MODE.  It is also OK if MAKE_ANCESTOR is not null and a
  58    directory DIR already exists.
  59
  60    Call ANNOUNCE (DIR, OPTIONS) just after successfully making DIR,
  61    even if some of the following actions fail.
  62
  63    Set DIR's owner to OWNER and group to GROUP, but leave the owner
  64    alone if OWNER is (uid_t) -1, and similarly for GROUP.
  65
  66    Set DIR's mode bits to MODE, except preserve any of the bits that
  67    correspond to zero bits in MODE_BITS.  In other words, MODE_BITS is
  68    a mask that specifies which of DIR's mode bits should be set or
  69    cleared.  MODE should be a subset of MODE_BITS, which in turn
  70    should be a subset of CHMOD_MODE_BITS.  Changing the mode in this
  71    way is necessary if DIR already existed or if MODE and MODE_BITS
  72    specify non-permissions bits like S_ISUID.
  73
  74    However, if PRESERVE_EXISTING is true and DIR already exists,
  75    do not attempt to set DIR's ownership and file mode bits.
  76
  77    This implementation assumes the current umask is zero.
  78
  79    Return true if DIR exists as a directory with the proper ownership
  80    and file mode bits when done, or if a child process has been
  81    dispatched to do the real work (though the child process may not
  82    have finished yet -- it is the caller's responsibility to handle
  83    this).  Report a diagnostic and return false on failure, storing
  84    '\0' into *DIR if an ancestor directory had problems.  */
  85
  86 bool
  87 make_dir_parents (char *dir,
  88                   struct savewd *wd,
  89                   int (*make_ancestor) (char const *, char const *, void *),
  90                   void *options,
  91                   mode_t mode,
  92                   void (*announce) (char const *, void *),
  93                   mode_t mode_bits,
  94                   uid_t owner,
  95                   gid_t group,
  96                   bool preserve_existing)
  97 {
  98   int mkdir_errno = (IS_ABSOLUTE_FILE_NAME (dir) ? 0 : savewd_errno (wd));
  99
 100   if (mkdir_errno == 0)
 101     {
 102       ptrdiff_t prefix_len = 0;
 103       int savewd_chdir_options = (HAVE_FCHMOD ? SAVEWD_CHDIR_SKIP_READABLE : 0);
 104
 105       if (make_ancestor)
 106         {
 107           prefix_len = mkancesdirs (dir, wd, make_ancestor, options);
 108           if (prefix_len < 0)
 109             {
 110               if (prefix_len < -1)
 111                 return true;
 112               mkdir_errno = errno;
 113             }
 114         }
 115
 116       if (0 <= prefix_len)
 117         {
 118           if (mkdir (dir + prefix_len, mode) == 0)
 119             {
 120               announce (dir, options);
 121               preserve_existing =
 122                 (owner == (uid_t) -1 && group == (gid_t) -1
 123                  && ! ((mode_bits & (S_ISUID | S_ISGID)) | (mode & S_ISVTX)));
 124               savewd_chdir_options |=
 125                 (SAVEWD_CHDIR_NOFOLLOW
 126                  | (mode & S_IRUSR ? SAVEWD_CHDIR_READABLE : 0));
 127             }
 128           else
 129             mkdir_errno = errno;
 130
 131           if (preserve_existing)
 132             {
 133               struct stat st;
 134               if (mkdir_errno == 0
 135                   || (mkdir_errno != ENOENT && make_ancestor
 136                       && stat (dir + prefix_len, &st) == 0
 137                       && S_ISDIR (st.st_mode)))
 138                 return true;
 139             }
 140           else
 141             {
 142               int open_result[2];
 143               int chdir_result =
 144                 savewd_chdir (wd, dir + prefix_len,
 145                               savewd_chdir_options, open_result);
 146               if (chdir_result < -1)
 147                 return true;
 148               else
 149                 {
 150                   bool chdir_ok = (chdir_result == 0);
 151                   int chdir_errno = errno;
 152                   int fd = open_result[0];
 153                   bool chdir_failed_unexpectedly =
 154                     (mkdir_errno == 0
 155                      && ((! chdir_ok && (mode & S_IXUSR))
 156                          || (fd < 0 && (mode & S_IRUSR))));
 157
 158                   if (chdir_failed_unexpectedly)
 159                     {
 160                       /* No need to save errno here; it's irrelevant.  */
 161                       if (0 <= fd)
 162                         close (fd);
 163                     }
 164                   else
 165                     {
 166                       mode_t mkdir_mode = (mkdir_errno == 0 ? mode : -1);
 167                       char const *subdir = (chdir_ok ? "." : dir + prefix_len);
 168                       if (dirchownmod (fd, subdir, mkdir_mode, owner, group,
 169                                        mode, mode_bits)
 170                           == 0)
 171                         return true;
 172                     }
 173
 174                   if (mkdir_errno == 0
 175                       || (mkdir_errno != ENOENT && make_ancestor
 176                           && errno != ENOTDIR))
 177                     {
 178                       error (0,
 179                              (! chdir_failed_unexpectedly ? errno
 180                               : ! chdir_ok && (mode & S_IXUSR) ? chdir_errno
 181                               : open_result[1]),
 182                              _(owner == (uid_t) -1 && group == (gid_t) -1
 183                                ? "cannot change permissions of %s"
 184                                : "cannot change owner and permissions of %s"),
 185                              quote (dir));
 186                       return false;
 187                     }
 188                 }
 189             }
 190         }
 191     }
 192
 193   error (0, mkdir_errno, _("cannot create directory %s"), quote (dir));
 194   return false;
 195 }