CC-tea/coreutils
1
0
Fork 0
mirror of git://git.sv.gnu.org/coreutils.git synced 2026-04-17 00:56:34 +02:00
Code Issues Projects Releases Wiki Activity
Files
a9bd274616a8d2e99736b498e657cda4e6954f3f
coreutils/src/ln.c
Paul Eggert 7a69df8899 cp,ln,mv: when skipping exit with nonzero status 
* NEWS, doc/coreutils.texi: Document this.
* src/copy.c (copy_internal):
* src/ln.c (do_link): Return false when skipping action due to
--interactive or --no-clobber.
* tests/cp/cp-i.sh, tests/cp/preserve-link.sh:
* tests/cp/slink-2-slink.sh, tests/mv/i-1.pl, tests/mv/i-5.sh:
* tests/mv/mv-n.sh, tests/mv/update.sh:
Adjust expectations of exit status to match revised behavior.
2023-01-31 08:54:37 -08:00

683 lines
23 KiB
C
Raw Blame History

/* 'ln' program to create links between files.
Copyright (C) 1986-2023 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
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
/* Written by Mike Parker and David MacKenzie. */
#include <config.h>
#include <stdio.h>
#include <sys/types.h>
#include <getopt.h>
#include "system.h"
#include "backupfile.h"
#include "die.h"
#include "error.h"
#include "fcntl-safer.h"
#include "filenamecat.h"
#include "file-set.h"
#include "force-link.h"
#include "hash.h"
#include "hash-triple.h"
#include "priv-set.h"
#include "relpath.h"
#include "same.h"
#include "unlinkdir.h"
#include "yesno.h"
#include "canonicalize.h"
/* The official name of this program (e.g., no 'g' prefix). */
#define PROGRAM_NAME "ln"
#define AUTHORS \
proper_name ("Mike Parker"), \
proper_name ("David MacKenzie")
/* FIXME: document */
static enum backup_type backup_type;
/* If true, make symbolic links; otherwise, make hard links. */
static bool symbolic_link;
/* If true, make symbolic links relative */
static bool relative;
/* If true, hard links are logical rather than physical. */
static bool logical = !!LINK_FOLLOWS_SYMLINKS;
/* If true, ask the user before removing existing files. */
static bool interactive;
/* If true, remove existing files unconditionally. */
static bool remove_existing_files;
/* If true, list each file as it is moved. */
static bool verbose;
/* If true, allow the superuser to *attempt* to make hard links
to directories. However, it appears that this option is not useful
in practice, since even the superuser is prohibited from hard-linking
directories on most existing systems (Solaris being an exception). */
static bool hard_dir_link;
/* If true, watch out for creating or removing hard links to directories. */
static bool beware_hard_dir_link;
/* If nonzero, and the specified destination is a symbolic link to a
directory, treat it just as if it were a directory. Otherwise, the
command 'ln --force --no-dereference file symlink-to-dir' deletes
symlink-to-dir before creating the new link. */
static bool dereference_dest_dir_symlinks = true;
/* This is a set of destination name/inode/dev triples for hard links
created by ln. Use this data structure to avoid data loss via a
sequence of commands like this:
rm -rf a b c; mkdir a b c; touch a/f b/f; ln -f a/f b/f c && rm -r a b */
static Hash_table *dest_set;
/* Initial size of the dest_set hash table. */
enum { DEST_INFO_INITIAL_CAPACITY = 61 };
static struct option const long_options[] =
{
{"backup", optional_argument, NULL, 'b'},
{"directory", no_argument, NULL, 'F'},
{"no-dereference", no_argument, NULL, 'n'},
{"no-target-directory", no_argument, NULL, 'T'},
{"force", no_argument, NULL, 'f'},
{"interactive", no_argument, NULL, 'i'},
{"suffix", required_argument, NULL, 'S'},
{"target-directory", required_argument, NULL, 't'},
{"logical", no_argument, NULL, 'L'},
{"physical", no_argument, NULL, 'P'},
{"relative", no_argument, NULL, 'r'},
{"symbolic", no_argument, NULL, 's'},
{"verbose", no_argument, NULL, 'v'},
{GETOPT_HELP_OPTION_DECL},
{GETOPT_VERSION_OPTION_DECL},
{NULL, 0, NULL, 0}
};
/* Return an errno value for a system call that returned STATUS.
This is zero if STATUS is zero, and is errno otherwise. */
static int
errnoize (int status)
{
return status < 0 ? errno : 0;
}
/* Return FROM represented as relative to the dir of TARGET.
The result is malloced. */
static char *
convert_abs_rel (char const *from, char const *target)
{
/* Get dirname to generate paths relative to. We don't resolve
the full TARGET as the last component could be an existing symlink. */
char *targetdir = dir_name (target);
char *realdest = canonicalize_filename_mode (targetdir, CAN_MISSING);
char *realfrom = canonicalize_filename_mode (from, CAN_MISSING);
char *relative_from = NULL;
if (realdest && realfrom)
{
/* Write to a PATH_MAX buffer. */
relative_from = xmalloc (PATH_MAX);
if (!relpath (realfrom, realdest, relative_from, PATH_MAX))
{
free (relative_from);
relative_from = NULL;
}
}
free (targetdir);
free (realdest);
free (realfrom);
return relative_from ? relative_from : xstrdup (from);
}
/* Link SOURCE to DESTDIR_FD + DEST_BASE atomically. DESTDIR_FD is
the directory containing DEST_BASE. Return 0 if successful, a
positive errno value on failure, and -1 if an atomic link cannot be
done. This handles the common case where the destination does not
already exist and -r is not specified. */
static int
atomic_link (char const *source, int destdir_fd, char const *dest_base)
{
return (symbolic_link
? (relative ? -1
: errnoize (symlinkat (source, destdir_fd, dest_base)))
: beware_hard_dir_link ? -1
: errnoize (linkat (AT_FDCWD, source, destdir_fd, dest_base,
logical ? AT_SYMLINK_FOLLOW : 0)));
}
/* Link SOURCE to a directory entry under DESTDIR_FD named DEST_BASE.
DEST is the full name of the destination, useful for diagnostics.
LINK_ERRNO is zero if the link has already been made,
positive if attempting the link failed with errno == LINK_ERRNO,
-1 if no attempt has been made to create the link.
Return true if successful. */
static bool
do_link (char const *source, int destdir_fd, char const *dest_base,
char const *dest, int link_errno)
{
struct stat source_stats;
int source_status = 1;
char *backup_base = NULL;
char *rel_source = NULL;
int nofollow_flag = logical ? 0 : AT_SYMLINK_NOFOLLOW;
if (link_errno < 0)
link_errno = atomic_link (source, destdir_fd, dest_base);
/* Get SOURCE_STATS if later code will need it, if only for sharper
diagnostics. */
if ((link_errno || dest_set) && !symbolic_link)
{
source_status = fstatat (AT_FDCWD, source, &source_stats, nofollow_flag);
if (source_status != 0)
{
error (0, errno, _("failed to access %s"), quoteaf (source));
return false;
}
}
if (link_errno)
{
if (!symbolic_link && !hard_dir_link && S_ISDIR (source_stats.st_mode))
{
error (0, 0, _("%s: hard link not allowed for directory"),
quotef (source));
return false;
}
if (relative)
source = rel_source = convert_abs_rel (source, dest);
bool force = (remove_existing_files || interactive
|| backup_type != no_backups);
if (force)
{
struct stat dest_stats;
if (fstatat (destdir_fd, dest_base, &dest_stats, AT_SYMLINK_NOFOLLOW)
!= 0)
{
if (errno != ENOENT)
{
error (0, errno, _("failed to access %s"), quoteaf (dest));
goto fail;
}
force = false;
}
else if (S_ISDIR (dest_stats.st_mode))
{
error (0, 0, _("%s: cannot overwrite directory"), quotef (dest));
goto fail;
}
else if (seen_file (dest_set, dest, &dest_stats))
{
/* The current target was created as a hard link to another
source file. */
error (0, 0,
_("will not overwrite just-created %s with %s"),
quoteaf_n (0, dest), quoteaf_n (1, source));
goto fail;
}
else
{
/* Beware removing DEST if it is the same directory entry as
SOURCE, because in that case removing DEST can cause the
subsequent link creation either to fail (for hard links), or
to replace a non-symlink DEST with a self-loop (for symbolic
links) which loses the contents of DEST. So, when backing
up, worry about creating hard links (since the backups cover
the symlink case); otherwise, worry about about -f. */
if (backup_type != no_backups
? !symbolic_link
: remove_existing_files)
{
/* Detect whether removing DEST would also remove SOURCE.
If the file has only one link then both are surely the
same directory entry. Otherwise check whether they point
to the same name in the same directory. */
if (source_status != 0)
source_status = stat (source, &source_stats);
if (source_status == 0
&& SAME_INODE (source_stats, dest_stats)
&& (source_stats.st_nlink == 1
|| same_nameat (AT_FDCWD, source,
destdir_fd, dest_base)))
{
error (0, 0, _("%s and %s are the same file"),
quoteaf_n (0, source), quoteaf_n (1, dest));
goto fail;
}
}
if (link_errno < 0 || link_errno == EEXIST)
{
if (interactive)
{
fprintf (stderr, _("%s: replace %s? "),
program_name, quoteaf (dest));
if (!yesno ())
{
free (rel_source);
return false;
}
}
if (backup_type != no_backups)
{
backup_base = find_backup_file_name (destdir_fd,
dest_base,
backup_type);
if (renameat (destdir_fd, dest_base,
destdir_fd, backup_base)
!= 0)
{
int rename_errno = errno;
free (backup_base);
backup_base = NULL;
if (rename_errno != ENOENT)
{
error (0, rename_errno, _("cannot backup %s"),
quoteaf (dest));
goto fail;
}
force = false;
}
}
}
}
}
/* If the attempt to create a link fails and we are removing or
backing up destinations, unlink the destination and try again.
On the surface, POSIX states that 'ln -f A B' unlinks B before trying
to link A to B. But strictly following this has the counterintuitive
effect of losing the contents of B if A does not exist. Fortunately,
POSIX 2008 clarified that an application is free to fail early if it
can prove that continuing onwards cannot succeed, so we can try to
link A to B before blindly unlinking B, thus sometimes attempting to
link a second time during a successful 'ln -f A B'.
Try to unlink DEST even if we may have backed it up successfully.
In some unusual cases (when DEST and the backup are hard-links
that refer to the same file), rename succeeds and DEST remains.
If we didn't remove DEST in that case, the subsequent symlink or
link call would fail. */
link_errno
= (symbolic_link
? force_symlinkat (source, destdir_fd, dest_base,
force, link_errno)
: force_linkat (AT_FDCWD, source, destdir_fd, dest_base,
logical ? AT_SYMLINK_FOLLOW : 0,
force, link_errno));
/* Until now, link_errno < 0 meant the link has not been tried.
From here on, link_errno < 0 means the link worked but
required removing the destination first. */
}
if (link_errno <= 0)
{
/* Right after creating a hard link, do this: (note dest name and
source_stats, which are also the just-linked-destinations stats) */
if (! symbolic_link)
record_file (dest_set, dest, &source_stats);
if (verbose)
{
char const *quoted_backup = "";
char const *backup_sep = "";
if (backup_base)
{
char *backup = backup_base;
void *alloc = NULL;
ptrdiff_t destdirlen = dest_base - dest;
if (0 < destdirlen)
{
alloc = xmalloc (destdirlen + strlen (backup_base) + 1);
backup = memcpy (alloc, dest, destdirlen);
strcpy (backup + destdirlen, backup_base);
}
quoted_backup = quoteaf_n (2, backup);
backup_sep = " ~ ";
free (alloc);
}
printf ("%s%s%s %c> %s\n", quoted_backup, backup_sep,
quoteaf_n (0, dest), symbolic_link ? '-' : '=',
quoteaf_n (1, source));
}
}
else
{
error (0, link_errno,
(symbolic_link
? (link_errno != ENAMETOOLONG && *source
? _("failed to create symbolic link %s")
: _("failed to create symbolic link %s -> %s"))
: (link_errno == EMLINK
? _("failed to create hard link to %.0s%s")
: (link_errno == EDQUOT || link_errno == EEXIST
|| link_errno == ENOSPC || link_errno == EROFS)
? _("failed to create hard link %s")
: _("failed to create hard link %s => %s"))),
quoteaf_n (0, dest), quoteaf_n (1, source));
if (backup_base)
{
if (renameat (destdir_fd, backup_base, destdir_fd, dest_base) != 0)
error (0, errno, _("cannot un-backup %s"), quoteaf (dest));
}
}
free (backup_base);
free (rel_source);
return link_errno <= 0;
fail:
free (rel_source);
return false;
}
void
usage (int status)
{
if (status != EXIT_SUCCESS)
emit_try_help ();
else
{
printf (_("\
Usage: %s [OPTION]... [-T] TARGET LINK_NAME\n\
or: %s [OPTION]... TARGET\n\
or: %s [OPTION]... TARGET... DIRECTORY\n\
or: %s [OPTION]... -t DIRECTORY TARGET...\n\
"),
program_name, program_name, program_name, program_name);
fputs (_("\
In the 1st form, create a link to TARGET with the name LINK_NAME.\n\
In the 2nd form, create a link to TARGET in the current directory.\n\
In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.\n\
Create hard links by default, symbolic links with --symbolic.\n\
By default, each destination (name of new link) should not already exist.\n\
When creating hard links, each TARGET must exist. Symbolic links\n\
can hold arbitrary text; if later resolved, a relative link is\n\
interpreted in relation to its parent directory.\n\
"), stdout);
emit_mandatory_arg_note ();
fputs (_("\
--backup[=CONTROL] make a backup of each existing destination file\n\
-b like --backup but does not accept an argument\n\
-d, -F, --directory allow the superuser to attempt to hard link\n\
directories (note: will probably fail due to\n\
system restrictions, even for the superuser)\n\
-f, --force remove existing destination files\n\
"), stdout);
fputs (_("\
-i, --interactive prompt whether to remove destinations\n\
-L, --logical dereference TARGETs that are symbolic links\n\
-n, --no-dereference treat LINK_NAME as a normal file if\n\
it is a symbolic link to a directory\n\
-P, --physical make hard links directly to symbolic links\n\
-r, --relative with -s, create links relative to link location\n\
-s, --symbolic make symbolic links instead of hard links\n\
"), stdout);
fputs (_("\
-S, --suffix=SUFFIX override the usual backup suffix\n\
-t, --target-directory=DIRECTORY specify the DIRECTORY in which to create\n\
the links\n\
-T, --no-target-directory treat LINK_NAME as a normal file always\n\
-v, --verbose print name of each linked file\n\
"), stdout);
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
emit_backup_suffix_note ();
printf (_("\
\n\
Using -s ignores -L and -P. Otherwise, the last option specified controls\n\
behavior when a TARGET is a symbolic link, defaulting to %s.\n\
"), LINK_FOLLOWS_SYMLINKS ? "-L" : "-P");
emit_ancillary_info (PROGRAM_NAME);
}
exit (status);
}
int
main (int argc, char **argv)
{
int c;
bool ok;
bool make_backups = false;
char const *backup_suffix = NULL;
char *version_control_string = NULL;
char const *target_directory = NULL;
int destdir_fd;
bool no_target_directory = false;
int n_files;
char **file;
int link_errno = -1;
initialize_main (&argc, &argv);
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
atexit (close_stdin);
symbolic_link = remove_existing_files = interactive = verbose
= hard_dir_link = false;
while ((c = getopt_long (argc, argv, "bdfinrst:vFLPS:T", long_options, NULL))
!= -1)
{
switch (c)
{
case 'b':
make_backups = true;
if (optarg)
version_control_string = optarg;
break;
case 'd':
case 'F':
hard_dir_link = true;
break;
case 'f':
remove_existing_files = true;
interactive = false;
break;
case 'i':
remove_existing_files = false;
interactive = true;
break;
case 'L':
logical = true;
break;
case 'n':
dereference_dest_dir_symlinks = false;
break;
case 'P':
logical = false;
break;
case 'r':
relative = true;
break;
case 's':
symbolic_link = true;
break;
case 't':
if (target_directory)
die (EXIT_FAILURE, 0, _("multiple target directories specified"));
else
{
struct stat st;
if (stat (optarg, &st) != 0)
die (EXIT_FAILURE, errno, _("failed to access %s"),
quoteaf (optarg));
if (! S_ISDIR (st.st_mode))
die (EXIT_FAILURE, 0, _("target %s is not a directory"),
quoteaf (optarg));
}
target_directory = optarg;
break;
case 'T':
no_target_directory = true;
break;
case 'v':
verbose = true;
break;
case 'S':
make_backups = true;
backup_suffix = optarg;
break;
case_GETOPT_HELP_CHAR;
case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
default:
usage (EXIT_FAILURE);
break;
}
}
n_files = argc - optind;
file = argv + optind;
if (n_files <= 0)
{
error (0, 0, _("missing file operand"));
usage (EXIT_FAILURE);
}
if (relative && !symbolic_link)
die (EXIT_FAILURE, 0, _("cannot do --relative without --symbolic"));
if (!hard_dir_link)
{
priv_set_remove_linkdir ();
beware_hard_dir_link = !cannot_unlink_dir ();
}
if (no_target_directory)
{
if (target_directory)
die (EXIT_FAILURE, 0,
_("cannot combine --target-directory "
"and --no-target-directory"));
if (n_files != 2)
{
if (n_files < 2)
error (0, 0,
_("missing destination file operand after %s"),
quoteaf (file[0]));
else
error (0, 0, _("extra operand %s"), quoteaf (file[2]));
usage (EXIT_FAILURE);
}
}
else if (n_files < 2 && !target_directory)
{
target_directory = ".";
destdir_fd = AT_FDCWD;
}
else
{
if (n_files == 2 && !target_directory)
link_errno = atomic_link (file[0], AT_FDCWD, file[1]);
if (link_errno < 0 || link_errno == EEXIST || link_errno == ENOTDIR
|| link_errno == EINVAL)
{
char const *d
= target_directory ? target_directory : file[n_files - 1];
int flags = (O_PATHSEARCH | O_DIRECTORY
| (dereference_dest_dir_symlinks ? 0 : O_NOFOLLOW));
destdir_fd = openat_safer (AT_FDCWD, d, flags);
int err = errno;
if (!O_DIRECTORY && 0 <= destdir_fd)
{
struct stat st;
err = (fstat (destdir_fd, &st) != 0 ? errno
: S_ISDIR (st.st_mode) ? 0 : ENOTDIR);
if (err != 0)
{
close (destdir_fd);
destdir_fd = -1;
}
}
if (0 <= destdir_fd)
{
n_files -= !target_directory;
target_directory = d;
}
else if (! (n_files == 2 && !target_directory))
die (EXIT_FAILURE, err, _("target %s"), quoteaf (d));
}
}
backup_type = (make_backups
? xget_version (_("backup type"), version_control_string)
: no_backups);
set_simple_backup_suffix (backup_suffix);
if (target_directory)
{
/* Create the data structure we'll use to record which hard links we
create. Used to ensure that ln detects an obscure corner case that
might result in user data loss. Create it only if needed. */
if (2 <= n_files
&& remove_existing_files
/* Don't bother trying to protect symlinks, since ln clobbering
a just-created symlink won't ever lead to real data loss. */
&& ! symbolic_link
/* No destination hard link can be clobbered when making
numbered backups. */
&& backup_type != numbered_backups)
{
dest_set = hash_initialize (DEST_INFO_INITIAL_CAPACITY,
NULL,
triple_hash,
triple_compare,
triple_free);
if (dest_set == NULL)
xalloc_die ();
}
ok = true;
for (int i = 0; i < n_files; ++i)
{
char *dest_base;
char *dest = file_name_concat (target_directory,
last_component (file[i]),
&dest_base);
strip_trailing_slashes (dest_base);
ok &= do_link (file[i], destdir_fd, dest_base, dest, -1);
free (dest);
}
}
else
ok = do_link (file[0], AT_FDCWD, file[1], file[1], link_errno);
main_exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
}
Reference in New Issue View Git Blame Copy Permalink