#include "dirname.h"
#include "euidaccess.h"
#include "error.h"
+#include "filenamecat.h"
#include "full-write.h"
#include "getpagesize.h"
#include "hash.h"
#include "hash-pjw.h"
-#include "path-concat.h"
#include "quote.h"
#include "same.h"
#include "savedir.h"
/* Initial size of the above hash table. */
#define DEST_INFO_INITIAL_CAPACITY 61
-static bool copy_internal (const char *src_path, const char *dst_path,
+static bool copy_internal (char const *src_name, char const *dst_name,
bool new_dst, dev_t device,
struct dir_list *ancestors,
const struct cp_options *x,
/* Pointers to the file names: they're used in the diagnostic that is issued
when we detect the user is trying to copy a directory into itself. */
-static char const *top_level_src_path;
-static char const *top_level_dst_path;
+static char const *top_level_src_name;
+static char const *top_level_dst_name;
/* The invocation name of this program. */
extern char *program_name;
return false;
}
-/* Read the contents of the directory SRC_PATH_IN, and recursively
- copy the contents to DST_PATH_IN. NEW_DST is true if
- DST_PATH_IN is a directory that was created previously in the
- recursion. SRC_SB and ANCESTORS describe SRC_PATH_IN.
- Set *COPY_INTO_SELF if SRC_PATH_IN is a parent of
- (or the same as) DST_PATH_IN; otherwise, clear it.
+/* Read the contents of the directory SRC_NAME_IN, and recursively
+ copy the contents to DST_NAME_IN. NEW_DST is true if
+ DST_NAME_IN is a directory that was created previously in the
+ recursion. SRC_SB and ANCESTORS describe SRC_NAME_IN.
+ Set *COPY_INTO_SELF if SRC_NAME_IN is a parent of
+ (or the same as) DST_NAME_IN; otherwise, clear it.
Return true if successful. */
static bool
-copy_dir (const char *src_path_in, const char *dst_path_in, bool new_dst,
+copy_dir (char const *src_name_in, char const *dst_name_in, bool new_dst,
const struct stat *src_sb, struct dir_list *ancestors,
const struct cp_options *x, bool *copy_into_self)
{
struct cp_options non_command_line_options = *x;
bool ok = true;
- name_space = savedir (src_path_in);
+ name_space = savedir (src_name_in);
if (name_space == NULL)
{
/* This diagnostic is a bit vague because savedir can fail in
several different ways. */
- error (0, errno, _("cannot access %s"), quote (src_path_in));
+ error (0, errno, _("cannot access %s"), quote (src_name_in));
return false;
}
while (*namep != '\0')
{
bool local_copy_into_self;
- char *src_path = path_concat (src_path_in, namep, NULL);
- char *dst_path = path_concat (dst_path_in, namep, NULL);
+ char *src_name = file_name_concat (src_name_in, namep, NULL);
+ char *dst_name = file_name_concat (dst_name_in, namep, NULL);
- ok &= copy_internal (src_path, dst_path, new_dst, src_sb->st_dev,
+ ok &= copy_internal (src_name, dst_name, new_dst, src_sb->st_dev,
ancestors, &non_command_line_options, false,
&local_copy_into_self, NULL);
*copy_into_self |= local_copy_into_self;
- free (dst_path);
- free (src_path);
+ free (dst_name);
+ free (src_name);
namep += strlen (namep) + 1;
}
return ok;
}
-/* Copy a regular file from SRC_PATH to DST_PATH.
+/* Copy a regular file from SRC_NAME to DST_NAME.
If the source file contains holes, copies holes and blocks of zeros
in the source file as holes in the destination file.
(Holes are read as zeroes by the `read' system call.)
X provides many option settings.
Return true if successful.
*NEW_DST is as in copy_internal. SRC_SB is the result
- of calling xstat (aka stat in this case) on SRC_PATH. */
+ of calling xstat (aka stat in this case) on SRC_NAME. */
static bool
-copy_reg (const char *src_path, const char *dst_path,
+copy_reg (char const *src_name, char const *dst_name,
const struct cp_options *x, mode_t dst_mode, bool *new_dst,
struct stat const *src_sb)
{
bool last_write_made_hole = false;
bool make_holes = false;
- source_desc = open (src_path, O_RDONLY);
+ source_desc = open (src_name, O_RDONLY);
source_desc = fd_safer (source_desc);
if (source_desc < 0)
{
- error (0, errno, _("cannot open %s for reading"), quote (src_path));
+ error (0, errno, _("cannot open %s for reading"), quote (src_name));
return false;
}
if (fstat (source_desc, &src_open_sb))
{
- error (0, errno, _("cannot fstat %s"), quote (src_path));
+ error (0, errno, _("cannot fstat %s"), quote (src_name));
return_val = false;
goto close_src_desc;
}
{
error (0, 0,
_("skipping file %s, as it was replaced while being copied"),
- quote (src_path));
+ quote (src_name));
return_val = false;
goto close_src_desc;
}
The if-block will be taken in move_mode. */
if (*new_dst)
{
- dest_desc = open (dst_path, O_WRONLY | O_CREAT, dst_mode);
+ dest_desc = open (dst_name, O_WRONLY | O_CREAT, dst_mode);
}
else
{
- dest_desc = open (dst_path, O_WRONLY | O_TRUNC, dst_mode);
+ dest_desc = open (dst_name, O_WRONLY | O_TRUNC, dst_mode);
if (dest_desc < 0 && x->unlink_dest_after_failed_open)
{
- if (unlink (dst_path))
+ if (unlink (dst_name) != 0)
{
- error (0, errno, _("cannot remove %s"), quote (dst_path));
+ error (0, errno, _("cannot remove %s"), quote (dst_name));
return_val = false;
goto close_src_desc;
}
*new_dst = true;
/* Try the open again, but this time with different flags. */
- dest_desc = open (dst_path, O_WRONLY | O_CREAT, dst_mode);
+ dest_desc = open (dst_name, O_WRONLY | O_CREAT, dst_mode);
}
}
dest_desc = fd_safer (dest_desc);
if (dest_desc < 0)
{
- error (0, errno, _("cannot create regular file %s"), quote (dst_path));
+ error (0, errno, _("cannot create regular file %s"), quote (dst_name));
return_val = false;
goto close_src_desc;
}
if (fstat (dest_desc, &sb))
{
- error (0, errno, _("cannot fstat %s"), quote (dst_path));
+ error (0, errno, _("cannot fstat %s"), quote (dst_name));
return_val = false;
goto close_src_and_dst_desc;
}
#if HAVE_STRUCT_STAT_ST_BLOCKS
if (x->sparse_mode == SPARSE_AUTO && S_ISREG (sb.st_mode))
{
- /* Use a heuristic to determine whether SRC_PATH contains any
+ /* Use a heuristic to determine whether SRC_NAME contains any
sparse blocks. */
if (fstat (source_desc, &sb))
{
- error (0, errno, _("cannot fstat %s"), quote (src_path));
+ error (0, errno, _("cannot fstat %s"), quote (src_name));
return_val = false;
goto close_src_and_dst_desc;
}
if (errno == EINTR)
continue;
#endif
- error (0, errno, _("reading %s"), quote (src_path));
+ error (0, errno, _("reading %s"), quote (src_name));
return_val = false;
goto close_src_and_dst_desc;
}
/* Make a hole. */
if (lseek (dest_desc, (off_t) n_read, SEEK_CUR) < 0L)
{
- error (0, errno, _("cannot lseek %s"), quote (dst_path));
+ error (0, errno, _("cannot lseek %s"), quote (dst_name));
return_val = false;
goto close_src_and_dst_desc;
}
size_t n = n_read;
if (full_write (dest_desc, buf, n) != n)
{
- error (0, errno, _("writing %s"), quote (dst_path));
+ error (0, errno, _("writing %s"), quote (dst_name));
return_val = false;
goto close_src_and_dst_desc;
}
|| full_write (dest_desc, "", 1) != 1)
#endif
{
- error (0, errno, _("writing %s"), quote (dst_path));
+ error (0, errno, _("writing %s"), quote (dst_name));
return_val = false;
}
}
close_src_and_dst_desc:
if (close (dest_desc) < 0)
{
- error (0, errno, _("closing %s"), quote (dst_path));
+ error (0, errno, _("closing %s"), quote (dst_name));
return_val = false;
}
close_src_desc:
if (close (source_desc) < 0)
{
- error (0, errno, _("closing %s"), quote (src_path));
+ error (0, errno, _("closing %s"), quote (src_name));
return_val = false;
}
successfully. */
static bool
-same_file_ok (const char *src_path, const struct stat *src_sb,
- const char *dst_path, const struct stat *dst_sb,
+same_file_ok (char const *src_name, struct stat const *src_sb,
+ char const *dst_name, struct stat const *dst_sb,
const struct cp_options *x, bool *return_now, bool *unlink_src)
{
const struct stat *src_sb_link;
know this here IFF preserving symlinks (aka xstat == lstat),
then it's ok -- as long as they are distinct. */
if (S_ISLNK (src_sb->st_mode) && S_ISLNK (dst_sb->st_mode))
- return ! same_name (src_path, dst_path);
+ return ! same_name (src_name, dst_name);
src_sb_link = src_sb;
dst_sb_link = dst_sb;
if (!same)
return true;
- if (lstat (dst_path, &tmp_dst_sb)
- || lstat (src_path, &tmp_src_sb))
+ if (lstat (dst_name, &tmp_dst_sb) != 0
+ || lstat (src_name, &tmp_src_sb) != 0)
return true;
src_sb_link = &tmp_src_sb;
return true;
}
- return ! same_name (src_path, dst_path);
+ return ! same_name (src_name, dst_name);
}
#if 0
/* FIXME: use or remove */
/* If we're making a backup, we'll detect the problem case in
- copy_reg because SRC_PATH will no longer exist. Allowing
+ copy_reg because SRC_NAME will no longer exist. Allowing
the test to be deferred lets cp do some useful things.
- But when creating hardlinks and SRC_PATH is a symlink
- but DST_PATH is not we must test anyway. */
+ But when creating hardlinks and SRC_NAME is a symlink
+ but DST_NAME is not we must test anyway. */
if (x->hard_link
|| !S_ISLNK (src_sb_link->st_mode)
|| S_ISLNK (dst_sb_link->st_mode))
/* They may refer to the same file if we're in move mode and the
target is a symlink. That is ok, since we remove any existing
destination file before opening it -- via `rename' if they're on
- the same file system, via `unlink (DST_PATH)' otherwise.
+ the same file system, via `unlink (DST_NAME)' otherwise.
It's also ok if they're distinct hard links to the same file. */
if (x->move_mode || x->unlink_dest_before_opening)
{
if (same_link
&& 1 < dst_sb_link->st_nlink
- && ! same_name (src_path, dst_path))
+ && ! same_name (src_name, dst_name))
{
if (x->move_mode)
{
{
if ( ! S_ISLNK (src_sb_link->st_mode))
tmp_src_sb = *src_sb_link;
- else if (stat (src_path, &tmp_src_sb))
+ else if (stat (src_name, &tmp_src_sb) != 0)
return true;
if ( ! S_ISLNK (dst_sb_link->st_mode))
tmp_dst_sb = *dst_sb_link;
- else if (stat (dst_path, &tmp_dst_sb))
+ else if (stat (dst_name, &tmp_dst_sb) != 0)
return true;
if ( ! SAME_INODE (tmp_src_sb, tmp_dst_sb))
}
static void
-overwrite_prompt (char const *dst_path, struct stat const *dst_sb)
+overwrite_prompt (char const *dst_name, struct stat const *dst_sb)
{
- if (euidaccess (dst_path, W_OK) != 0)
+ if (euidaccess (dst_name, W_OK) != 0)
{
fprintf (stderr,
_("%s: overwrite %s, overriding mode %04lo? "),
- program_name, quote (dst_path),
+ program_name, quote (dst_name),
(unsigned long int) (dst_sb->st_mode & CHMOD_MODE_BITS));
}
else
{
fprintf (stderr, _("%s: overwrite %s? "),
- program_name, quote (dst_path));
+ program_name, quote (dst_name));
}
}
}
/* Return true if there is an entry in hash table, HT,
- for the file described by FILENAME and STATS. */
+ for the file described by FILE and STATS. */
static bool
-seen_file (Hash_table const *ht, char const *filename,
+seen_file (Hash_table const *ht, char const *file,
struct stat const *stats)
{
struct F_triple new_ent;
if (ht == NULL)
return false;
- new_ent.name = (char *) filename;
+ new_ent.name = (char *) file;
new_ent.st_ino = stats->st_ino;
new_ent.st_dev = stats->st_dev;
return !!hash_lookup (ht, &new_ent);
}
-/* Record destination filename, FILENAME, and dev/ino from *STATS,
+/* Record destination file, FILE, and dev/ino from *STATS,
in the hash table, HT. If HT is NULL, return immediately.
- If STATS is NULL, call lstat on FILENAME to get the device
+ If STATS is NULL, call lstat on FILE to get the device
and inode numbers. If that lstat fails, simply return.
If memory allocation fails, exit immediately. */
static void
-record_file (Hash_table *ht, char const *filename,
+record_file (Hash_table *ht, char const *file,
struct stat const *stats)
{
struct F_triple *ent;
return;
ent = xmalloc (sizeof *ent);
- ent->name = xstrdup (filename);
+ ent->name = xstrdup (file);
if (stats)
{
ent->st_ino = stats->st_ino;
else
{
struct stat sb;
- if (lstat (filename, &sb))
+ if (lstat (file, &sb) != 0)
return;
ent->st_ino = sb.st_ino;
ent->st_dev = sb.st_dev;
}
}
-/* When effecting a move (e.g., for mv(1)), and given the name DST_PATH
+/* When effecting a move (e.g., for mv(1)), and given the name DST_NAME
of the destination and a corresponding stat buffer, DST_SB, return
true if the logical `move' operation should _not_ proceed.
Otherwise, return false.
Depending on options specified in X, this code may issue an
- interactive prompt asking whether it's ok to overwrite DST_PATH. */
+ interactive prompt asking whether it's ok to overwrite DST_NAME. */
static bool
abandon_move (const struct cp_options *x,
- char const *dst_path,
+ char const *dst_name,
struct stat const *dst_sb)
{
assert (x->move_mode);
|| ((x->interactive == I_ASK_USER
|| (x->interactive == I_UNSPECIFIED
&& x->stdin_tty
- && UNWRITABLE (dst_path, dst_sb->st_mode)))
- && (overwrite_prompt (dst_path, dst_sb), 1)
+ && UNWRITABLE (dst_name, dst_sb->st_mode)))
+ && (overwrite_prompt (dst_name, dst_sb), 1)
&& ! yesno ()));
}
-/* Copy the file SRC_PATH to the file DST_PATH. The files may be of
- any type. NEW_DST should be true if the file DST_PATH cannot
+/* Copy the file SRC_NAME to the file DST_NAME. The files may be of
+ any type. NEW_DST should be true if the file DST_NAME cannot
exist because its parent directory was just created; NEW_DST should
- be false if DST_PATH might already exist. DEVICE is the device
+ be false if DST_NAME might already exist. DEVICE is the device
number of the parent directory, or 0 if the parent of this file is
not known. ANCESTORS points to a linked, null terminated list of
- devices and inodes of parent directories of SRC_PATH. COMMAND_LINE_ARG
- is true iff SRC_PATH was specified on the command line.
- Set *COPY_INTO_SELF if SRC_PATH is a parent of (or the
- same as) DST_PATH; otherwise, clear it.
+ devices and inodes of parent directories of SRC_NAME. COMMAND_LINE_ARG
+ is true iff SRC_NAME was specified on the command line.
+ Set *COPY_INTO_SELF if SRC_NAME is a parent of (or the
+ same as) DST_NAME; otherwise, clear it.
Return true if successful. */
static bool
-copy_internal (const char *src_path, const char *dst_path,
+copy_internal (char const *src_name, char const *dst_name,
bool new_dst,
dev_t device,
struct dir_list *ancestors,
*copy_into_self = false;
- if (XSTAT (x, src_path, &src_sb))
+ if (XSTAT (x, src_name, &src_sb) != 0)
{
- error (0, errno, _("cannot stat %s"), quote (src_path));
+ error (0, errno, _("cannot stat %s"), quote (src_name));
return false;
}
if (S_ISDIR (src_type) && !x->recursive)
{
- error (0, 0, _("omitting directory %s"), quote (src_path));
+ error (0, 0, _("omitting directory %s"), quote (src_name));
return false;
}
{
if ( ! S_ISDIR (src_sb.st_mode)
&& x->backup_type == no_backups
- && seen_file (x->src_info, src_path, &src_sb))
+ && seen_file (x->src_info, src_name, &src_sb))
{
error (0, 0, _("warning: source file %s specified more than once"),
- quote (src_path));
+ quote (src_name));
return true;
}
- record_file (x->src_info, src_path, &src_sb);
+ record_file (x->src_info, src_name, &src_sb);
}
if (!new_dst)
{
- if (XSTAT (x, dst_path, &dst_sb))
+ if (XSTAT (x, dst_name, &dst_sb) != 0)
{
if (errno != ENOENT)
{
- error (0, errno, _("cannot stat %s"), quote (dst_path));
+ error (0, errno, _("cannot stat %s"), quote (dst_name));
return false;
}
else
{
bool return_now;
bool unlink_src;
- bool ok = same_file_ok (src_path, &src_sb, dst_path, &dst_sb,
+ bool ok = same_file_ok (src_name, &src_sb, dst_name, &dst_sb,
x, &return_now, &unlink_src);
if (unlink_src)
{
- if (!abandon_move (x, dst_path, &dst_sb)
- && unlink (src_path))
+ if (!abandon_move (x, dst_name, &dst_sb)
+ && unlink (src_name) != 0)
{
- error (0, errno, _("cannot remove %s"), quote (src_path));
+ error (0, errno, _("cannot remove %s"), quote (src_name));
return false;
}
- /* Tell the caller that there's no need to remove src_path. */
+ /* Tell the caller that there's no need to remove src_name. */
if (rename_succeeded)
*rename_succeeded = true;
}
if (! ok)
{
error (0, 0, _("%s and %s are the same file"),
- quote_n (0, src_path), quote_n (1, dst_path));
+ quote_n (0, src_name), quote_n (1, dst_name));
return false;
}
{
error (0, 0,
_("cannot overwrite non-directory %s with directory %s"),
- quote_n (0, dst_path), quote_n (1, src_path));
+ quote_n (0, dst_name), quote_n (1, src_name));
return false;
}
Note that it works fine if you use --backup=numbered. */
if (command_line_arg
&& x->backup_type != numbered_backups
- && seen_file (x->dest_info, dst_path, &dst_sb))
+ && seen_file (x->dest_info, dst_name, &dst_sb))
{
error (0, 0,
_("will not overwrite just-created %s with %s"),
- quote_n (0, dst_path), quote_n (1, src_path));
+ quote_n (0, dst_name), quote_n (1, src_name));
return false;
}
}
{
error (0, 0,
_("cannot overwrite directory %s with non-directory"),
- quote (dst_path));
+ quote (dst_name));
return false;
}
? UTIMECMP_TRUNCATE_SOURCE
: 0);
- if (0 <= utimecmp (dst_path, &dst_sb, &src_sb, options))
+ if (0 <= utimecmp (dst_name, &dst_sb, &src_sb, options))
{
/* We're using --update and the destination is not older
than the source, so do not copy or move. Pretend the
/* cp and mv treat -i and -f differently. */
if (x->move_mode)
{
- if (abandon_move (x, dst_path, &dst_sb))
+ if (abandon_move (x, dst_name, &dst_sb))
{
/* Pretend the rename succeeded, so the caller (mv)
doesn't end up removing the source file. */
{
if (x->interactive == I_ALWAYS_NO
|| (x->interactive == I_ASK_USER
- && (overwrite_prompt (dst_path, &dst_sb), 1)
+ && (overwrite_prompt (dst_name, &dst_sb), 1)
&& ! yesno ()))
{
return true;
if (S_ISDIR (dst_sb.st_mode))
{
error (0, 0, _("cannot overwrite directory %s"),
- quote (dst_path));
+ quote (dst_name));
return false;
}
{
error (0, 0,
_("cannot move directory onto non-directory: %s -> %s"),
- quote_n (0, src_path), quote_n (0, dst_path));
+ quote_n (0, src_name), quote_n (0, dst_name));
return false;
}
}
if (x->backup_type != no_backups && !S_ISDIR (dst_sb.st_mode))
{
- char *tmp_backup = find_backup_file_name (dst_path,
+ char *tmp_backup = find_backup_file_name (dst_name,
x->backup_type);
/* Detect (and fail) when creating the backup file would
would leave two zero-length files: a and a~. */
/* FIXME: but simply change e.g., the final a~ to `./a~'
and the source will still be destroyed. */
- if (STREQ (tmp_backup, src_path))
+ if (STREQ (tmp_backup, src_name))
{
const char *fmt;
fmt = (x->move_mode
? _("backing up %s would destroy source; %s not moved")
: _("backing up %s would destroy source; %s not copied"));
error (0, 0, fmt,
- quote_n (0, dst_path),
- quote_n (1, src_path));
+ quote_n (0, dst_name),
+ quote_n (1, src_name));
free (tmp_backup);
return false;
}
/* FIXME: use fts:
- Using alloca for a pathname that may be (in theory) arbitrarily
+ Using alloca for a file name that may be arbitrarily
long is not recommended. In fact, even forming such a name
should be discouraged. Eventually, this code will be rewritten
to use fts, so using alloca here will be less of a problem. */
ASSIGN_STRDUPA (dst_backup, tmp_backup);
free (tmp_backup);
- if (rename (dst_path, dst_backup))
+ if (rename (dst_name, dst_backup) != 0)
{
if (errno != ENOENT)
{
- error (0, errno, _("cannot backup %s"), quote (dst_path));
+ error (0, errno, _("cannot backup %s"), quote (dst_name));
return false;
}
else
|| (x->dereference == DEREF_NEVER
&& S_ISLNK (src_sb.st_mode))))
{
- if (unlink (dst_path) && errno != ENOENT)
+ if (unlink (dst_name) != 0 && errno != ENOENT)
{
- error (0, errno, _("cannot remove %s"), quote (dst_path));
+ error (0, errno, _("cannot remove %s"), quote (dst_name));
return false;
}
new_dst = true;
sure we'll create a directory. */
if (x->verbose && !S_ISDIR (src_type))
{
- printf ("%s -> %s", quote_n (0, src_path), quote_n (1, dst_path));
+ printf ("%s -> %s", quote_n (0, src_name), quote_n (1, dst_name));
if (backup_succeeded)
printf (_(" (backup: %s)"), quote (dst_backup));
putchar ('\n');
}
- /* Associate the destination path with the source device and inode
+ /* Associate the destination file name with the source device and inode
so that if we encounter a matching dev/ino pair in the source tree
we can arrange to create a hard link between the corresponding names
in the destination tree.
|| x->dereference == DEREF_ALWAYS))
|| (x->recursive && S_ISDIR (src_type)))
{
- earlier_file = remember_copied (dst_path, src_sb.st_ino, src_sb.st_dev);
+ earlier_file = remember_copied (dst_name, src_sb.st_ino, src_sb.st_dev);
}
/* Did we copy this inode somewhere else (in this command line argument)
directories). */
if (S_ISDIR (src_type))
{
- /* If src_path and earlier_file refer to the same directory entry,
+ /* If src_name and earlier_file refer to the same directory entry,
then warn about copying a directory into itself. */
- if (same_name (src_path, earlier_file))
+ if (same_name (src_name, earlier_file))
{
error (0, 0, _("cannot copy a directory, %s, into itself, %s"),
- quote_n (0, top_level_src_path),
- quote_n (1, top_level_dst_path));
+ quote_n (0, top_level_src_name),
+ quote_n (1, top_level_dst_name));
*copy_into_self = true;
}
else
{
error (0, 0, _("will not create hard link %s to directory %s"),
- quote_n (0, dst_path), quote_n (1, earlier_file));
+ quote_n (0, dst_name), quote_n (1, earlier_file));
}
goto un_backup;
}
{
- bool link_failed = (link (earlier_file, dst_path) != 0);
+ bool link_failed = (link (earlier_file, dst_name) != 0);
/* If the link failed because of an existing destination,
remove that file and then call link again. */
if (link_failed && errno == EEXIST)
{
- if (unlink (dst_path))
+ if (unlink (dst_name) != 0)
{
- error (0, errno, _("cannot remove %s"), quote (dst_path));
+ error (0, errno, _("cannot remove %s"), quote (dst_name));
goto un_backup;
}
- link_failed = (link (earlier_file, dst_path) != 0);
+ link_failed = (link (earlier_file, dst_name) != 0);
}
if (link_failed)
{
error (0, errno, _("cannot create hard link %s to %s"),
- quote_n (0, dst_path), quote_n (1, earlier_file));
+ quote_n (0, dst_name), quote_n (1, earlier_file));
goto un_backup;
}
if (x->move_mode)
{
- if (rename (src_path, dst_path) == 0)
+ if (rename (src_name, dst_name) == 0)
{
if (x->verbose && S_ISDIR (src_type))
- printf ("%s -> %s\n", quote_n (0, src_path), quote_n (1, dst_path));
+ printf ("%s -> %s\n", quote_n (0, src_name), quote_n (1, dst_name));
if (rename_succeeded)
*rename_succeeded = true;
if (command_line_arg)
{
- /* Record destination dev/ino/filename, so that if we are asked
+ /* Record destination dev/ino/name, so that if we are asked
to overwrite that file again, we can detect it and fail. */
/* It's fine to use the _source_ stat buffer (src_sb) to get the
_destination_ dev/ino, since the rename above can't have
changed those, and `mv' always uses lstat.
We could limit it further by operating
only on non-directories. */
- record_file (x->dest_info, dst_path, &src_sb);
+ record_file (x->dest_info, dst_name, &src_sb);
}
return true;
subdirectory of itself. */
if (errno == EINVAL
- /* When src_path is on an NFS file system, some types of
+ /* When src_name is on an NFS file system, some types of
clients, e.g., SunOS4.1.4 and IRIX-5.3, set errno to EIO
instead. Testing for this here risks misinterpreting a real
I/O error as an attempt to move a directory into itself, so
failing with a specific errno value. Expect problems on
non-POSIX systems. */
error (0, 0, _("cannot move %s to a subdirectory of itself, %s"),
- quote_n (0, top_level_src_path),
- quote_n (1, top_level_dst_path));
+ quote_n (0, top_level_src_name),
+ quote_n (1, top_level_dst_name));
/* Note that there is no need to call forget_created here,
(compare with the other calls in this file) since the
fail. Etc. */
error (0, errno,
_("cannot move %s to %s"),
- quote_n (0, src_path), quote_n (1, dst_path));
+ quote_n (0, src_name), quote_n (1, dst_name));
forget_created (src_sb.st_ino, src_sb.st_dev);
return false;
}
/* The rename attempt has failed. Remove any existing destination
file so that a cross-device `mv' acts as if it were really using
the rename syscall. */
- if (unlink (dst_path) && errno != ENOENT)
+ if (unlink (dst_name) != 0 && errno != ENOENT)
{
error (0, errno,
_("inter-device move failed: %s to %s; unable to remove target"),
- quote_n (0, src_path), quote_n (1, dst_path));
+ quote_n (0, src_name), quote_n (1, dst_name));
forget_created (src_sb.st_ino, src_sb.st_dev);
return false;
}
if (is_ancestor (&src_sb, ancestors))
{
error (0, 0, _("cannot copy cyclic symbolic link %s"),
- quote (src_path));
+ quote (src_name));
goto un_backup;
}
/* Create the new directory writable and searchable, so
we can create new entries in it. */
- if (mkdir (dst_path, (src_mode & x->umask_kill) | S_IRWXU))
+ if (mkdir (dst_name, (src_mode & x->umask_kill) | S_IRWXU) != 0)
{
error (0, errno, _("cannot create directory %s"),
- quote (dst_path));
+ quote (dst_name));
goto un_backup;
}
numbers into the search structure, so that we can
avoid copying it again. */
- if (! remember_created (dst_path))
+ if (! remember_created (dst_name))
goto un_backup;
if (x->verbose)
- printf ("%s -> %s\n", quote_n (0, src_path), quote_n (1, dst_path));
+ printf ("%s -> %s\n", quote_n (0, src_name), quote_n (1, dst_name));
}
/* Are we crossing a file system boundary? */
/* Copy the contents of the directory. */
- if (! copy_dir (src_path, dst_path, new_dst, &src_sb, dir, x,
+ if (! copy_dir (src_name, dst_name, new_dst, &src_sb, dir, x,
copy_into_self))
{
/* Don't just return here -- otherwise, the failure to read a
{
preserve_metadata = false;
- if (*src_path != '/')
+ if (*src_name != '/')
{
- /* Check that DST_PATH denotes a file in the current directory. */
+ /* Check that DST_NAME denotes a file in the current directory. */
struct stat dot_sb;
struct stat dst_parent_sb;
char *dst_parent;
bool in_current_dir;
- dst_parent = dir_name (dst_path);
+ dst_parent = dir_name (dst_name);
in_current_dir = (STREQ (".", dst_parent)
/* If either stat call fails, it's ok not to report
- the failure and say dst_path is in the current
+ the failure and say dst_name is in the current
directory. Other things will fail later. */
|| stat (".", &dot_sb)
|| stat (dst_parent, &dst_parent_sb)
{
error (0, 0,
_("%s: can make relative symbolic links only in current directory"),
- quote (dst_path));
+ quote (dst_name));
goto un_backup;
}
}
- if (symlink (src_path, dst_path))
+ if (symlink (src_name, dst_name) != 0)
{
error (0, errno, _("cannot create symbolic link %s to %s"),
- quote_n (0, dst_path), quote_n (1, src_path));
+ quote_n (0, dst_name), quote_n (1, src_name));
goto un_backup;
}
}
else if (x->hard_link)
{
preserve_metadata = false;
- if (link (src_path, dst_path))
+ if (link (src_name, dst_name))
{
- error (0, errno, _("cannot create link %s"), quote (dst_path));
+ error (0, errno, _("cannot create link %s"), quote (dst_name));
goto un_backup;
}
}
/* POSIX says the permission bits of the source file must be
used as the 3rd argument in the open call, but that's not consistent
with historical practice. */
- if (! copy_reg (src_path, dst_path, x,
+ if (! copy_reg (src_name, dst_name, x,
get_dest_mode (x, src_mode), &new_dst, &src_sb))
goto un_backup;
}
#ifdef S_ISFIFO
if (S_ISFIFO (src_type))
{
- if (mkfifo (dst_path, get_dest_mode (x, src_mode)))
+ if (mkfifo (dst_name, get_dest_mode (x, src_mode)))
{
- error (0, errno, _("cannot create fifo %s"), quote (dst_path));
+ error (0, errno, _("cannot create fifo %s"), quote (dst_name));
goto un_backup;
}
}
if (S_ISBLK (src_type) || S_ISCHR (src_type)
|| S_ISSOCK (src_type))
{
- if (mknod (dst_path, get_dest_mode (x, src_mode), src_sb.st_rdev))
+ if (mknod (dst_name, get_dest_mode (x, src_mode), src_sb.st_rdev))
{
error (0, errno, _("cannot create special file %s"),
- quote (dst_path));
+ quote (dst_name));
goto un_backup;
}
}
#ifdef S_ISLNK
if (S_ISLNK (src_type))
{
- char *src_link_val = xreadlink (src_path, src_sb.st_size);
+ char *src_link_val = xreadlink (src_name, src_sb.st_size);
if (src_link_val == NULL)
{
- error (0, errno, _("cannot read symbolic link %s"), quote (src_path));
+ error (0, errno, _("cannot read symbolic link %s"), quote (src_name));
goto un_backup;
}
- if (!symlink (src_link_val, dst_path))
+ if (symlink (src_link_val, dst_name) == 0)
free (src_link_val);
else
{
FIXME: This behavior isn't documented, and seems wrong
in some cases, e.g., if the destination symlink has the
wrong ownership, permissions, or time stamps. */
- char *dest_link_val = xreadlink (dst_path, dst_sb.st_size);
+ char *dest_link_val = xreadlink (dst_name, dst_sb.st_size);
if (STREQ (dest_link_val, src_link_val))
same_link = true;
free (dest_link_val);
if (! same_link)
{
error (0, saved_errno, _("cannot create symbolic link %s"),
- quote (dst_path));
+ quote (dst_name));
goto un_backup;
}
}
/* Preserve the owner and group of the just-`copied'
symbolic link, if possible. */
# if HAVE_LCHOWN
- if (lchown (dst_path, src_sb.st_uid, src_sb.st_gid) != 0
+ if (lchown (dst_name, src_sb.st_uid, src_sb.st_gid) != 0
&& ! chown_failure_ok (x))
{
error (0, errno, _("failed to preserve ownership for %s"),
- dst_path);
+ dst_name);
goto un_backup;
}
# else
else
#endif
{
- error (0, 0, _("%s has unknown file type"), quote (src_path));
+ error (0, 0, _("%s has unknown file type"), quote (src_name));
goto un_backup;
}
if (command_line_arg)
- record_file (x->dest_info, dst_path, NULL);
+ record_file (x->dest_info, dst_name, NULL);
if ( ! preserve_metadata)
return true;
timespec[1].tv_sec = src_sb.st_mtime;
timespec[1].tv_nsec = TIMESPEC_NS (src_sb.st_mtim);
- if (utimens (dst_path, timespec))
+ if (utimens (dst_name, timespec) != 0)
{
- error (0, errno, _("preserving times for %s"), quote (dst_path));
+ error (0, errno, _("preserving times for %s"), quote (dst_name));
if (x->require_preserve)
return false;
}
if (x->preserve_ownership
&& (new_dst || !SAME_OWNER_AND_GROUP (src_sb, dst_sb)))
{
- if (chown (dst_path, src_sb.st_uid, src_sb.st_gid) == 0)
+ if (chown (dst_name, src_sb.st_uid, src_sb.st_gid) == 0)
chown_succeeded = true;
else if (! chown_failure_ok (x))
{
error (0, errno, _("failed to preserve ownership for %s"),
- quote (dst_path));
+ quote (dst_name));
if (x->require_preserve)
return false;
}
#if HAVE_STRUCT_STAT_ST_AUTHOR
/* Preserve the st_author field. */
{
- file_t file = file_name_lookup (dst_path, 0, 0);
+ file_t file = file_name_lookup (dst_name, 0, 0);
if (file == MACH_PORT_NULL)
- error (0, errno, _("failed to lookup file %s"), quote (dst_path));
+ error (0, errno, _("failed to lookup file %s"), quote (dst_name));
else
{
error_t err = file_chauthor (file, src_sb.st_author);
if (err)
error (0, err, _("failed to preserve authorship for %s"),
- quote (dst_path));
+ quote (dst_name));
mach_port_deallocate (mach_task_self (), file);
}
}
if ((x->preserve_mode || new_dst)
&& (x->copy_as_regular || S_ISREG (src_type) || S_ISDIR (src_type)))
{
- if (chmod (dst_path, get_dest_mode (x, src_mode)))
+ if (chmod (dst_name, get_dest_mode (x, src_mode)) != 0)
{
- error (0, errno, _("setting permissions for %s"), quote (dst_path));
+ error (0, errno, _("setting permissions for %s"), quote (dst_name));
if (x->set_mode || x->require_preserve)
return false;
}
if (dst_backup)
{
- if (rename (dst_backup, dst_path))
- error (0, errno, _("cannot un-backup %s"), quote (dst_path));
+ if (rename (dst_backup, dst_name) != 0)
+ error (0, errno, _("cannot un-backup %s"), quote (dst_name));
else
{
if (x->verbose)
printf (_("%s -> %s (unbackup)\n"),
- quote_n (0, dst_backup), quote_n (1, dst_path));
+ quote_n (0, dst_backup), quote_n (1, dst_name));
}
}
return false;
return true;
}
-/* Copy the file SRC_PATH to the file DST_PATH. The files may be of
- any type. NONEXISTENT_DST should be true if the file DST_PATH
+/* Copy the file SRC_NAME to the file DST_NAME. The files may be of
+ any type. NONEXISTENT_DST should be true if the file DST_NAME
is known not to exist (e.g., because its parent directory was just
- created); NONEXISTENT_DST should be false if DST_PATH might already
+ created); NONEXISTENT_DST should be false if DST_NAME might already
exist. OPTIONS is ... FIXME-describe
- Set *COPY_INTO_SELF if SRC_PATH is a parent of (or the
- same as) DST_PATH; otherwise, set clear it.
+ Set *COPY_INTO_SELF if SRC_NAME is a parent of (or the
+ same as) DST_NAME; otherwise, set clear it.
Return true if successful. */
extern bool
-copy (const char *src_path, const char *dst_path,
+copy (char const *src_name, char const *dst_name,
bool nonexistent_dst, const struct cp_options *options,
bool *copy_into_self, bool *rename_succeeded)
{
top level source and destination directory names where they're used.
An alternative is to use COPY_INTO_SELF and print the diagnostic
from every caller -- but I don't want to do that. */
- top_level_src_path = src_path;
- top_level_dst_path = dst_path;
+ top_level_src_name = src_name;
+ top_level_dst_name = dst_name;
- return copy_internal (src_path, dst_path, nonexistent_dst, 0, NULL,
+ return copy_internal (src_name, dst_name, nonexistent_dst, 0, NULL,
options, true, copy_into_self, rename_succeeded);
}
projects / platform / upstream / coreutils.git / commitdiff