/* makepath.c -- Ensure that a directory path exists.
- Copyright (C) 1990, 1997, 1998 Free Software Foundation, Inc.
+
+ Copyright (C) 1990, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by David MacKenzie <djm@gnu.ai.mit.edu> and Jim Meyering. */
# include <config.h>
#endif
-#if __GNUC__
-# define alloca __builtin_alloca
-#else
-# if HAVE_ALLOCA_H
-# include <alloca.h>
-# else
-# ifdef _AIX
- # pragma alloca
-# else
-char *alloca ();
-# endif
-# endif
-#endif
+#include "makepath.h"
+
+#include <alloca.h>
#include <stdio.h>
#include <sys/types.h>
# include <unistd.h>
#endif
-#if STAT_MACROS_BROKEN
-# undef S_ISDIR
-#endif
-
-#if !defined(S_ISDIR) && defined(S_IFDIR)
-# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
-#endif
-
-#if STDC_HEADERS
-# include <stdlib.h>
-#endif
-
-#if HAVE_ERRNO_H
-# include <errno.h>
-#endif
-
-#ifndef errno
-extern int errno;
-#endif
-
-#if HAVE_STRING_H
-# include <string.h>
-#else
-# include <strings.h>
-# ifndef strchr
-# define strchr index
-# endif
-#endif
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
-#ifndef S_IWUSR
-# define S_IWUSR 0200
-#endif
-
-#ifndef S_IXUSR
-# define S_IXUSR 0100
-#endif
-
-#define WX_USR (S_IWUSR | S_IXUSR)
-
-#ifdef __MSDOS__
-typedef int uid_t;
-typedef int gid_t;
-#endif
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
#include "save-cwd.h"
-#include "makepath.h"
+#include "dirname.h"
#include "error.h"
+#include "quote.h"
+#include "stat-macros.h"
-void strip_trailing_slashes ();
+#define WX_USR (S_IWUSR | S_IXUSR)
#define CLEANUP_CWD \
do \
Restore working directory. */ \
if (do_chdir) \
{ \
- int fail = restore_cwd (&cwd, NULL, NULL); \
+ if (restore_cwd (&cwd) != 0) \
+ { \
+ int _saved_errno = errno; \
+ error (0, errno, \
+ _("failed to return to initial working directory")); \
+ free_cwd (&cwd); \
+ errno = _saved_errno; \
+ return 1; \
+ } \
free_cwd (&cwd); \
- if (fail) \
- return 1; \
} \
} \
while (0)
} \
while (0)
+/* Attempt to create directory DIR (aka DIRPATH) with the specified MODE.
+ If CREATED_DIR_P is non-NULL, set *CREATED_DIR_P if this
+ function creates DIR and clear it otherwise. Give a diagnostic and
+ return false if DIR cannot be created or cannot be determined to
+ exist already. Use DIRPATH in any diagnostic, not DIR.
+ Note that if DIR already exists, this function returns true
+ (indicating success) and clears *CREATED_DIR_P. */
+
+bool
+make_dir (const char *dir, const char *dirpath, mode_t mode,
+ bool *created_dir_p)
+{
+ bool ok = true;
+ bool created_dir;
+
+ created_dir = (mkdir (dir, mode) == 0);
+
+ if (!created_dir)
+ {
+ struct stat stats;
+ int saved_errno = errno;
+
+ /* The mkdir and stat calls below may appear to be reversed.
+ They are not. It is important to call mkdir first and then to
+ call stat (to distinguish the three cases) only if mkdir fails.
+ The alternative to this approach is to `stat' each directory,
+ then to call mkdir if it doesn't exist. But if some other process
+ were to create the directory between the stat & mkdir, the mkdir
+ would fail with EEXIST. */
+
+ if (stat (dir, &stats))
+ {
+ error (0, saved_errno, _("cannot create directory %s"),
+ quote (dirpath));
+ ok = false;
+ }
+ else if (!S_ISDIR (stats.st_mode))
+ {
+ error (0, 0, _("%s exists but is not a directory"), quote (dirpath));
+ ok = false;
+ }
+ else
+ {
+ /* DIR (aka DIRPATH) already exists and is a directory. */
+ }
+ }
+
+ if (created_dir_p)
+ *created_dir_p = created_dir;
+
+ return ok;
+}
+
/* Ensure that the directory ARGPATH exists.
- Remove any trailing slashes from ARGPATH before calling this function.
Create any leading directories that don't already exist, with
permissions PARENT_MODE.
If VERBOSE_FMT_STRING is nonzero, use it as a printf format
string for printing a message after successfully making a directory,
with the name of the directory that was just made as an argument.
- If PRESERVE_EXISTING is non-zero and ARGPATH is an existing directory,
+ If PRESERVE_EXISTING is true and ARGPATH is an existing directory,
then do not attempt to set its permissions and ownership.
- Return 0 if ARGPATH exists as a directory with the proper
- ownership and permissions when done, otherwise 1. */
+ Return true iff ARGPATH exists as a directory with the proper
+ ownership and permissions when done. */
-int
+bool
make_path (const char *argpath,
- int mode,
- int parent_mode,
+ mode_t mode,
+ mode_t parent_mode,
uid_t owner,
gid_t group,
- int preserve_existing,
+ bool preserve_existing,
const char *verbose_fmt_string)
{
struct stat stats;
- int retval = 0;
+ bool retval = true;
if (stat (argpath, &stats))
{
char *slash;
- int tmp_mode; /* Initial perms for leading dirs. */
- int re_protect; /* Should leading dirs be unwritable? */
+ mode_t tmp_mode; /* Initial perms for leading dirs. */
+ bool re_protect; /* Should leading dirs be unwritable? */
struct ptr_list
{
char *dirname_end;
struct ptr_list *next;
};
struct ptr_list *p, *leading_dirs = NULL;
- int do_chdir; /* Whether to chdir before each mkdir. */
+ bool do_chdir; /* Whether to chdir before each mkdir. */
struct saved_cwd cwd;
char *basename_dir;
char *dirpath;
/* Temporarily relax umask in case it's overly restrictive. */
- int oldmask = umask (0);
+ mode_t oldmask = umask (0);
/* Make a copy of ARGPATH that we can scribble NULs on. */
dirpath = (char *) alloca (strlen (argpath) + 1);
their owners, we need to fix their permissions after making them. */
if (((parent_mode & WX_USR) != WX_USR)
|| ((owner != (uid_t) -1 || group != (gid_t) -1)
- && (parent_mode & 07000) != 0))
+ && (parent_mode & (S_ISUID | S_ISGID | S_ISVTX)) != 0))
{
- tmp_mode = 0700;
- re_protect = 1;
+ tmp_mode = S_IRWXU;
+ re_protect = true;
}
else
{
tmp_mode = parent_mode;
- re_protect = 0;
+ re_protect = false;
}
/* If we can record the current working directory, we may be able
to do the chdir optimization. */
- do_chdir = !save_cwd (&cwd);
+ do_chdir = (save_cwd (&cwd) == 0);
/* If we've saved the cwd and DIRPATH is an absolute pathname,
we must chdir to `/' in order to enable the chdir optimization.
So if chdir ("/") fails, turn off the optimization. */
- if (do_chdir && *dirpath == '/' && chdir ("/") < 0)
- do_chdir = 0;
+ if (do_chdir && dirpath[0] == '/')
+ {
+ /* POSIX says "//" might be special, so chdir to "//" if the
+ file name starts with exactly two slashes. */
+ char const *root = "//" + (dirpath[1] != '/' || dirpath[2] == '/');
+ if (chdir (root) != 0)
+ do_chdir = false;
+ }
slash = dirpath;
while (1)
{
- int newly_created_dir = 1;
+ bool newly_created_dir;
/* slash points to the leftmost unprocessed component of dirpath. */
basename_dir = slash;
if (!do_chdir)
basename_dir = dirpath;
- /* The mkdir and stat calls below appear to be reversed.
- They are not. It is important to call mkdir first and then to
- call stat (to distinguish the three cases) only if mkdir fails.
- The alternative to this approach is to `stat' each directory,
- then to call mkdir if it doesn't exist. But if some other process
- were to create the directory between the stat & mkdir, the mkdir
- would fail with EEXIST. */
-
*slash = '\0';
- if (mkdir (basename_dir, tmp_mode))
+ if (! make_dir (basename_dir, dirpath, tmp_mode, &newly_created_dir))
{
- if (stat (basename_dir, &stats))
- {
- error (0, errno, "cannot create directory `%s'", dirpath);
- CLEANUP;
- return 1;
- }
- else if (!S_ISDIR (stats.st_mode))
- {
- error (0, 0, "`%s' exists but is not a directory", dirpath);
- CLEANUP;
- return 1;
- }
- else
- {
- /* DIRPATH already exists and is a directory. */
- newly_created_dir = 0;
- }
+ CLEANUP;
+ return false;
}
if (newly_created_dir)
{
if (verbose_fmt_string)
- fprintf (stderr, verbose_fmt_string, dirpath);
+ error (0, 0, verbose_fmt_string, quote (dirpath));
if ((owner != (uid_t) -1 || group != (gid_t) -1)
&& chown (basename_dir, owner, group)
-#if defined(AFS) && defined (EPERM)
+#if defined AFS && defined EPERM
&& errno != EPERM
#endif
)
{
- error (0, errno, "%s", dirpath);
+ error (0, errno, _("cannot change owner and/or group of %s"),
+ quote (dirpath));
CLEANUP;
- return 1;
+ return false;
}
if (re_protect)
stat and mkdir process O(n^2) file name components. */
if (do_chdir && chdir (basename_dir) < 0)
{
- error (0, errno, "cannot chdir to directory, %s", dirpath);
+ error (0, errno, _("cannot chdir to directory %s"),
+ quote (dirpath));
CLEANUP;
- return 1;
+ return false;
}
*slash++ = '/';
if (!do_chdir)
basename_dir = dirpath;
+ /* Done creating leading directories. Restore original umask. */
+ umask (oldmask);
+
/* We're done making leading directories.
Create the final component of the path. */
- /* The path could end in "/." or contain "/..", so test
- if we really have to create the directory. */
-
- if (stat (basename_dir, &stats) && mkdir (basename_dir, mode))
+ if (! make_dir (basename_dir, dirpath, mode, NULL))
{
- error (0, errno, "cannot create directory `%s'", dirpath);
CLEANUP;
- return 1;
+ return false;
}
- /* Done creating directories. Restore original umask. */
- umask (oldmask);
-
if (verbose_fmt_string != NULL)
- error (0, 0, verbose_fmt_string, dirpath);
+ error (0, 0, verbose_fmt_string, quote (dirpath));
- if (owner != (uid_t) -1 && group != (gid_t) -1)
+ if (owner != (uid_t) -1 || group != (gid_t) -1)
{
if (chown (basename_dir, owner, group)
#ifdef AFS
#endif
)
{
- error (0, errno, "cannot chown %s", dirpath);
- retval = 1;
- }
- /* chown may have turned off some permission bits we wanted. */
- if ((mode & 07000) != 0 && chmod (basename_dir, mode))
- {
- error (0, errno, "cannot chmod %s", dirpath);
- retval = 1;
+ error (0, errno, _("cannot change owner and/or group of %s"),
+ quote (dirpath));
+ retval = false;
}
}
+ /* The above chown may have turned off some permission bits in MODE.
+ Another reason we may have to use chmod here is that mkdir(2) is
+ required to honor only the file permission bits. In particular,
+ it need not honor the `special' bits, so if MODE includes any
+ special bits, set them here. */
+ if ((mode & ~S_IRWXUGO)
+ && chmod (basename_dir, mode))
+ {
+ error (0, errno, _("cannot change permissions of %s"),
+ quote (dirpath));
+ retval = false;
+ }
+
CLEANUP_CWD;
/* If the mode for leading directories didn't include owner "wx"
*(p->dirname_end) = '\0';
if (chmod (dirpath, parent_mode))
{
- error (0, errno, "%s", dirpath);
- retval = 1;
+ error (0, errno, _("cannot change permissions of %s"),
+ quote (dirpath));
+ retval = false;
}
}
}
if (!S_ISDIR (stats.st_mode))
{
- error (0, 0, "`%s' exists but is not a directory", dirpath);
- return 1;
+ error (0, 0, _("%s exists but is not a directory"), quote (dirpath));
+ return false;
}
if (!preserve_existing)
#endif
)
{
- error (0, errno, "%s", dirpath);
- retval = 1;
+ error (0, errno, _("cannot change owner and/or group of %s"),
+ quote (dirpath));
+ retval = false;
}
if (chmod (dirpath, mode))
{
- error (0, errno, "%s", dirpath);
- retval = 1;
+ error (0, errno, _("cannot change permissions of %s"),
+ quote (dirpath));
+ retval = false;
}
}
}