src/ln.c - coreutils-8.23
Global variables defined
Functions defined
Macros defined
Source code
#include <config.h>
#include <stdio.h>
#include <sys/types.h>
#include <getopt.h>
#include "system.h"
#include "backupfile.h"
#include "error.h"
#include "filenamecat.h"
#include "file-set.h"
#include "hash.h"
#include "hash-triple.h"
#include "quote.h"
#include "relpath.h"
#include "same.h"
#include "yesno.h"
#include "canonicalize.h"
#define PROGRAM_NAME "ln"
#define AUTHORS \
proper_name ("Mike Parker"), \
proper_name ("David MacKenzie")
FIXMEstatic enum backup_type backup_type;
static bool symbolic_link;
static bool relative;
static bool logical = !!LINK_FOLLOWS_SYMLINKS;
static bool interactive;
static bool remove_existing_files;
static bool verbose;
static bool hard_dir_link;
static bool dereference_dest_dir_symlinks = true;
static Hash_table *dest_set;
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}
};
static bool
errno_nonexisting (int err)
{
return err == ENOENT || err == ENAMETOOLONG || err == ENOTDIR || err == ELOOP;
}
static bool
target_directory_operand (char const *file)
{
char const *b = last_component (file);
size_t blen = strlen (b);
bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1]));
struct stat st;
int stat_result =
(dereference_dest_dir_symlinks ? stat (file, &st) : lstat (file, &st));
int err = (stat_result == 0 ? 0 : errno);
bool is_a_dir = !err && S_ISDIR (st.st_mode);
if (err && ! errno_nonexisting (errno))
error (EXIT_FAILURE, err, _("failed to access %s"), quote (file));
if (is_a_dir < looks_like_a_dir)
error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file));
return is_a_dir;
}
static char *
convert_abs_rel (const char *from, const char *target)
{
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)
{
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);
}
static bool
do_link (const char *source, const char *dest)
{
struct stat source_stats;
struct stat dest_stats;
char *dest_backup = NULL;
char *rel_source = NULL;
bool dest_lstat_ok = false;
bool source_is_dir = false;
bool ok;
if (!symbolic_link)
{
if ((logical ? stat (source, &source_stats)
: lstat (source, &source_stats))
!= 0)
{
error (0, errno, _("failed to access %s"), quote (source));
return false;
}
if (S_ISDIR (source_stats.st_mode))
{
source_is_dir = true;
if (! hard_dir_link)
{
error (0, 0, _("%s: hard link not allowed for directory"),
quote (source));
return false;
}
}
}
if (remove_existing_files || interactive || backup_type != no_backups)
{
dest_lstat_ok = (lstat (dest, &dest_stats) == 0);
if (!dest_lstat_ok && errno != ENOENT)
{
error (0, errno, _("failed to access %s"), quote (dest));
return false;
}
}
if (dest_lstat_ok
&& dest_set != NULL
&& seen_file (dest_set, dest, &dest_stats))
{
error (0, 0,
_("will not overwrite just-created %s with %s"),
quote_n (0, dest), quote_n (1, source));
return false;
}
if ((remove_existing_files
|| (!symbolic_link && backup_type != no_backups))
&& dest_lstat_ok
&& (backup_type == no_backups || !symbolic_link)
&& (!symbolic_link || stat (source, &source_stats) == 0)
&& SAME_INODE (source_stats, dest_stats)
&& (source_stats.st_nlink == 1 || same_name (source, dest)))
{
error (0, 0, _("%s and %s are the same file"),
quote_n (0, source), quote_n (1, dest));
return false;
}
if (dest_lstat_ok)
{
if (S_ISDIR (dest_stats.st_mode))
{
error (0, 0, _("%s: cannot overwrite directory"), quote (dest));
return false;
}
if (interactive)
{
fprintf (stderr, _("%s: replace %s? "), program_name, quote (dest));
if (!yesno ())
return true;
remove_existing_files = true;
}
if (backup_type != no_backups)
{
dest_backup = find_backup_file_name (dest, backup_type);
if (rename (dest, dest_backup) != 0)
{
int rename_errno = errno;
free (dest_backup);
dest_backup = NULL;
if (rename_errno != ENOENT)
{
error (0, rename_errno, _("cannot backup %s"), quote (dest));
return false;
}
}
}
}
if (relative)
source = rel_source = convert_abs_rel (source, dest);
ok = ((symbolic_link ? symlink (source, dest)
: linkat (AT_FDCWD, source, AT_FDCWD, dest,
logical ? AT_SYMLINK_FOLLOW : 0))
== 0);
if (!ok && errno == EEXIST && (remove_existing_files || dest_backup))
{
if (unlink (dest) != 0)
{
error (0, errno, _("cannot remove %s"), quote (dest));
free (dest_backup);
free (rel_source);
return false;
}
ok = ((symbolic_link ? symlink (source, dest)
: linkat (AT_FDCWD, source, AT_FDCWD, dest,
logical ? AT_SYMLINK_FOLLOW : 0))
== 0);
}
if (ok)
{
if (! symbolic_link)
record_file (dest_set, dest, &source_stats);
if (verbose)
{
if (dest_backup)
printf ("%s ~ ", quote (dest_backup));
printf ("%s %c> %s\n", quote_n (0, dest), (symbolic_link ? '-' : '='),
quote_n (1, source));
}
}
else
{
error (0, errno,
(symbolic_link
? (errno != ENAMETOOLONG && *source
? _("failed to create symbolic link %s")
: _("failed to create symbolic link %s -> %s"))
: (errno == EMLINK && !source_is_dir
? _("failed to create hard link to %.0s%s")
: (errno == EDQUOT || errno == EEXIST || errno == ENOSPC
|| errno == EROFS)
? _("failed to create hard link %s")
: _("failed to create hard link %s => %s"))),
quote_n (0, dest), quote_n (1, source));
if (dest_backup)
{
if (rename (dest_backup, dest) != 0)
error (0, errno, _("cannot un-backup %s"), quote (dest));
}
}
free (dest_backup);
free (rel_source);
return ok;
}
void
usage (int status)
{
if (status != EXIT_SUCCESS)
emit_try_help ();
else
{
printf (_("\
Usage: %s [OPTION]... [-T] TARGET LINK_NAME (1st form)\n\
or: %s [OPTION]... TARGET (2nd form)\n\
or: %s [OPTION]... TARGET... DIRECTORY (3rd form)\n\
or: %s [OPTION]... -t DIRECTORY TARGET... (4th form)\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 create symbolic 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);
fputs (_("\
\n\
The backup suffix is '~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
The version control method may be selected via the --backup option or through\n\
the VERSION_CONTROL environment variable. Here are the values:\n\
\n\
"), stdout);
fputs (_("\
none, off never make backups (even if --backup is given)\n\
numbered, t make numbered backups\n\
existing, nil numbered if numbered backups exist, simple otherwise\n\
simple, never always make simple backups\n\
"), stdout);
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 ();
}
exit (status);
}
int
main (int argc, char **argv)
{
int c;
bool ok;
bool make_backups = false;
char *backup_suffix_string;
char *version_control_string = NULL;
char const *target_directory = NULL;
bool no_target_directory = false;
int n_files;
char **file;
initialize_main (&argc, &argv);
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
atexit (close_stdin);
FIXME backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
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)
error (EXIT_FAILURE, 0, _("multiple target directories specified"));
else
{
struct stat st;
if (stat (optarg, &st) != 0)
error (EXIT_FAILURE, errno, _("failed to access %s"),
quote (optarg));
if (! S_ISDIR (st.st_mode))
error (EXIT_FAILURE, 0, _("target %s is not a directory"),
quote (optarg));
}
target_directory = optarg;
break;
case 'T':
no_target_directory = true;
break;
case 'v':
verbose = true;
break;
case 'S':
make_backups = true;
backup_suffix_string = 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 (no_target_directory)
{
if (target_directory)
error (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"),
quote (file[0]));
else
error (0, 0, _("extra operand %s"), quote (file[2]));
usage (EXIT_FAILURE);
}
}
else if (!target_directory)
{
if (n_files < 2)
target_directory = ".";
else if (2 <= n_files && target_directory_operand (file[n_files - 1]))
target_directory = file[--n_files];
else if (2 < n_files)
error (EXIT_FAILURE, 0, _("target %s is not a directory"),
quote (file[n_files - 1]));
}
if (backup_suffix_string)
simple_backup_suffix = xstrdup (backup_suffix_string);
backup_type = (make_backups
? xget_version (_("backup type"), version_control_string)
: no_backups);
if (relative && !symbolic_link)
{
error (EXIT_FAILURE, 0,
_("cannot do --relative without --symbolic"));
}
if (target_directory)
{
int i;
if (2 <= n_files
&& remove_existing_files
&& ! symbolic_link
&& 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 (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], dest);
free (dest);
}
}
else
ok = do_link (file[0], file[1]);
exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
}