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 the ownership will change, create the directory with
 119              more restrictive permissions at first, so unauthorized
 120              users cannot nip in before the directory is ready.  */
 121           mode_t mkdir_mode = mode;
 122           if (! (owner == (uid_t) -1 && group == (gid_t) -1))
 123             mkdir_mode &= S_IRWXU;
 124
 125           if (mkdir (dir + prefix_len, mkdir_mode) == 0)
 126             {
 127               announce (dir, options);
 128               preserve_existing =
 129                 (owner == (uid_t) -1 && group == (gid_t) -1
 130                  && ! ((mode_bits & (S_ISUID | S_ISGID)) | (mode & S_ISVTX)));
 131               savewd_chdir_options |=
 132                 (SAVEWD_CHDIR_NOFOLLOW
 133                  | (mode & S_IRUSR ? SAVEWD_CHDIR_READABLE : 0));
 134             }
 135           else
 136             {
 137               mkdir_errno = errno;
 138               mkdir_mode = -1;
 139             }
 140
 141           if (preserve_existing)
 142             {
 143               struct stat st;
 144               if (mkdir_errno == 0
 145                   || (mkdir_errno != ENOENT && make_ancestor
 146                       && stat (dir + prefix_len, &st) == 0
 147                       && S_ISDIR (st.st_mode)))
 148                 return true;
 149             }
 150           else
 151             {
 152               int open_result[2];
 153               int chdir_result =
 154                 savewd_chdir (wd, dir + prefix_len,
 155                               savewd_chdir_options, open_result);
 156               if (chdir_result < -1)
 157                 return true;
 158               else
 159                 {
 160                   bool chdir_ok = (chdir_result == 0);
 161                   int chdir_errno = errno;
 162                   int fd = open_result[0];
 163                   bool chdir_failed_unexpectedly =
 164                     (mkdir_errno == 0
 165                      && ((! chdir_ok && (mode & S_IXUSR))
 166                          || (fd < 0 && (mode & S_IRUSR))));
 167
 168                   if (chdir_failed_unexpectedly)
 169                     {
 170                       /* No need to save errno here; it's irrelevant.  */
 171                       if (0 <= fd)
 172                         close (fd);
 173                     }
 174                   else
 175                     {
 176                       char const *subdir = (chdir_ok ? "." : dir + prefix_len);
 177                       if (dirchownmod (fd, subdir, mkdir_mode, owner, group,
 178                                        mode, mode_bits)
 179                           == 0)
 180                         return true;
 181                     }
 182
 183                   if (mkdir_errno == 0
 184                       || (mkdir_errno != ENOENT && make_ancestor
 185                           && errno != ENOTDIR))
 186                     {
 187                       error (0,
 188                              (! chdir_failed_unexpectedly ? errno
 189                               : ! chdir_ok && (mode & S_IXUSR) ? chdir_errno
 190                               : open_result[1]),
 191                              _(owner == (uid_t) -1 && group == (gid_t) -1
 192                                ? "cannot change permissions of %s"
 193                                : "cannot change owner and permissions of %s"),
 194                              quote (dir));
 195                       return false;
 196                     }
 197                 }
 198             }
 199         }
 200     }
 201
 202   error (0, mkdir_errno, _("cannot create directory %s"), quote (dir));
 203   return false;
 204 }