src/ln.c

   1 /* `ln' program to create links between files.
   2    Copyright (C) 1986, 1989-1991, 1995-2006 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17 \f
  18 /* Written by Mike Parker and David MacKenzie. */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <sys/types.h>
  23 #include <getopt.h>
  24
  25 #include "system.h"
  26 #include "same.h"
  27 #include "backupfile.h"
  28 #include "error.h"
  29 #include "filenamecat.h"
  30 #include "quote.h"
  31 #include "yesno.h"
  32
  33 /* The official name of this program (e.g., no `g' prefix).  */
  34 #define PROGRAM_NAME "ln"
  35
  36 #define AUTHORS "Mike Parker", "David MacKenzie"
  37
  38 #ifndef ENABLE_HARD_LINK_TO_SYMLINK_WARNING
  39 # define ENABLE_HARD_LINK_TO_SYMLINK_WARNING 0
  40 #endif
  41
  42 /* In being careful not even to try to make hard links to directories,
  43    we have to know whether link(2) follows symlinks.  If it does, then
  44    we have to *stat* the `source' to see if the resulting link would be
  45    to a directory.  Otherwise, we have to use *lstat* so that we allow
  46    users to make hard links to symlinks-that-point-to-directories.  */
  47
  48 #if LINK_FOLLOWS_SYMLINKS
  49 # define STAT_LIKE_LINK(File, Stat_buf) \
  50   stat (File, Stat_buf)
  51 #else
  52 # define STAT_LIKE_LINK(File, Stat_buf) \
  53   lstat (File, Stat_buf)
  54 #endif
  55
  56 /* The name by which the program was run, for error messages.  */
  57 char *program_name;
  58
  59 /* FIXME: document */
  60 static enum backup_type backup_type;
  61
  62 /* If true, make symbolic links; otherwise, make hard links.  */
  63 static bool symbolic_link;
  64
  65 /* If true, ask the user before removing existing files.  */
  66 static bool interactive;
  67
  68 /* If true, remove existing files unconditionally.  */
  69 static bool remove_existing_files;
  70
  71 /* If true, list each file as it is moved. */
  72 static bool verbose;
  73
  74 /* If true, allow the superuser to *attempt* to make hard links
  75    to directories.  However, it appears that this option is not useful
  76    in practice, since even the superuser is prohibited from hard-linking
  77    directories on most (all?) existing systems.  */
  78 static bool hard_dir_link;
  79
  80 /* If nonzero, and the specified destination is a symbolic link to a
  81    directory, treat it just as if it were a directory.  Otherwise, the
  82    command `ln --force --no-dereference file symlink-to-dir' deletes
  83    symlink-to-dir before creating the new link.  */
  84 static bool dereference_dest_dir_symlinks = true;
  85
  86 static struct option const long_options[] =
  87 {
  88   {"backup", optional_argument, NULL, 'b'},
  89   {"directory", no_argument, NULL, 'F'},
  90   {"no-dereference", no_argument, NULL, 'n'},
  91   {"no-target-directory", no_argument, NULL, 'T'},
  92   {"force", no_argument, NULL, 'f'},
  93   {"interactive", no_argument, NULL, 'i'},
  94   {"suffix", required_argument, NULL, 'S'},
  95   {"target-directory", required_argument, NULL, 't'},
  96   {"symbolic", no_argument, NULL, 's'},
  97   {"verbose", no_argument, NULL, 'v'},
  98   {GETOPT_HELP_OPTION_DECL},
  99   {GETOPT_VERSION_OPTION_DECL},
 100   {NULL, 0, NULL, 0}
 101 };
 102
 103 /* FILE is the last operand of this command.  Return true if FILE is a
 104    directory.  But report an error there is a problem accessing FILE,
 105    or if FILE does not exist but would have to refer to an existing
 106    directory if it referred to anything at all.  */
 107
 108 static bool
 109 target_directory_operand (char const *file)
 110 {
 111   char const *b = last_component (file);
 112   size_t blen = strlen (b);
 113   bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1]));
 114   struct stat st;
 115   int stat_result =
 116     (dereference_dest_dir_symlinks ? stat (file, &st) : lstat (file, &st));
 117   int err = (stat_result == 0 ? 0 : errno);
 118   bool is_a_dir = !err && S_ISDIR (st.st_mode);
 119   if (err && err != ENOENT)
 120     error (EXIT_FAILURE, err, _("accessing %s"), quote (file));
 121   if (is_a_dir < looks_like_a_dir)
 122     error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file));
 123   return is_a_dir;
 124 }
 125
 126 /* Make a link DEST to the (usually) existing file SOURCE.
 127    Symbolic links to nonexistent files are allowed.
 128    Return true if successful.  */
 129
 130 static bool
 131 do_link (const char *source, const char *dest)
 132 {
 133   struct stat source_stats;
 134   struct stat dest_stats;
 135   char *dest_backup = NULL;
 136   bool lstat_ok = false;
 137   bool source_is_dir = false;
 138   bool ok;
 139
 140   /* Use stat here instead of lstat.
 141      On SVR4, link does not follow symlinks, so this check disallows
 142      making hard links to symlinks that point to directories.  Big deal.
 143      On other systems, link follows symlinks, so this check is right.  */
 144   if (!symbolic_link)
 145     {
 146       if (STAT_LIKE_LINK (source, &source_stats) != 0)
 147         {
 148           error (0, errno, _("accessing %s"), quote (source));
 149           return false;
 150         }
 151
 152       if (ENABLE_HARD_LINK_TO_SYMLINK_WARNING
 153           && S_ISLNK (source_stats.st_mode))
 154         {
 155           error (0, 0, _("%s: warning: making a hard link to a symbolic link\
 156  is not portable"),
 157                  quote (source));
 158         }
 159
 160       if (S_ISDIR (source_stats.st_mode))
 161         {
 162           source_is_dir = true;
 163           if (! hard_dir_link)
 164             {
 165               error (0, 0, _("%s: hard link not allowed for directory"),
 166                      quote (source));
 167               return false;
 168             }
 169         }
 170     }
 171
 172   if (remove_existing_files || interactive || backup_type != no_backups)
 173     {
 174       lstat_ok = (lstat (dest, &dest_stats) == 0);
 175       if (!lstat_ok && errno != ENOENT)
 176         {
 177           error (0, errno, _("accessing %s"), quote (dest));
 178           return false;
 179         }
 180     }
 181
 182   /* If --force (-f) has been specified without --backup, then before
 183      making a link ln must remove the destination file if it exists.
 184      (with --backup, it just renames any existing destination file)
 185      But if the source and destination are the same, don't remove
 186      anything and fail right here.  */
 187   if (remove_existing_files
 188       && lstat_ok
 189       /* Allow `ln -sf --backup k k' to succeed in creating the
 190          self-referential symlink, but don't allow the hard-linking
 191          equivalent: `ln -f k k' (with or without --backup) to get
 192          beyond this point, because the error message you'd get is
 193          misleading.  */
 194       && (backup_type == no_backups || !symbolic_link)
 195       && (!symbolic_link || stat (source, &source_stats) == 0)
 196       && SAME_INODE (source_stats, dest_stats)
 197       /* The following detects whether removing DEST will also remove
 198          SOURCE.  If the file has only one link then both are surely
 199          the same link.  Otherwise check whether they point to the same
 200          name in the same directory.  */
 201       && (source_stats.st_nlink == 1 || same_name (source, dest)))
 202     {
 203       error (0, 0, _("%s and %s are the same file"),
 204              quote_n (0, source), quote_n (1, dest));
 205       return false;
 206     }
 207
 208   if (lstat_ok)
 209     {
 210       if (S_ISDIR (dest_stats.st_mode))
 211         {
 212           error (0, 0, _("%s: cannot overwrite directory"), quote (dest));
 213           return false;
 214         }
 215       if (interactive)
 216         {
 217           fprintf (stderr, _("%s: replace %s? "), program_name, quote (dest));
 218           if (!yesno ())
 219             return true;
 220           remove_existing_files = true;
 221         }
 222
 223       if (backup_type != no_backups)
 224         {
 225           dest_backup = find_backup_file_name (dest, backup_type);
 226           if (rename (dest, dest_backup) != 0)
 227             {
 228               int rename_errno = errno;
 229               free (dest_backup);
 230               dest_backup = NULL;
 231               if (rename_errno != ENOENT)
 232                 {
 233                   error (0, rename_errno, _("cannot backup %s"), quote (dest));
 234                   return false;
 235                 }
 236             }
 237         }
 238     }
 239
 240   ok = ((symbolic_link ? symlink (source, dest) : link (source, dest))
 241         == 0);
 242
 243   /* If the attempt to create a link failed and we are removing or
 244      backing up destinations, unlink the destination and try again.
 245
 246      POSIX 1003.1-2004 requires that ln -f A B must unlink B even on
 247      failure (e.g., when A does not exist).  This is counterintuitive,
 248      and we submitted a defect report
 249      <http://www.opengroup.org/austin/mailarchives/ag-review/msg01794.html>
 250      (2004-06-24).  If the committee does not fix the standard we'll
 251      have to change the behavior of ln -f, at least if POSIXLY_CORRECT
 252      is set.  In the meantime ln -f A B will not unlink B unless the
 253      attempt to link A to B failed because B already existed.
 254
 255      Try to unlink DEST even if we may have backed it up successfully.
 256      In some unusual cases (when DEST and DEST_BACKUP are hard-links
 257      that refer to the same file), rename succeeds and DEST remains.
 258      If we didn't remove DEST in that case, the subsequent symlink or link
 259      call would fail.  */
 260
 261   if (!ok && errno == EEXIST && (remove_existing_files || dest_backup))
 262     {
 263       if (unlink (dest) != 0)
 264         {
 265           error (0, errno, _("cannot remove %s"), quote (dest));
 266           free (dest_backup);
 267           return false;
 268         }
 269
 270       ok = ((symbolic_link ? symlink (source, dest) : link (source, dest))
 271             == 0);
 272     }
 273
 274   if (ok)
 275     {
 276       if (verbose)
 277         {
 278           if (dest_backup)
 279             printf ("%s ~ ", quote (dest_backup));
 280           printf ("%s %c> %s\n", quote_n (0, dest), (symbolic_link ? '-' : '='),
 281                   quote_n (1, source));
 282         }
 283     }
 284   else
 285     {
 286       error (0, errno,
 287              (symbolic_link
 288               ? (errno != ENAMETOOLONG && *source
 289                  ? _("creating symbolic link %s")
 290                  : _("creating symbolic link %s -> %s"))
 291               : (errno == EMLINK && !source_is_dir
 292                  ? _("creating hard link to %.0s%s")
 293                  : (errno == EDQUOT || errno == EEXIST || errno == ENOSPC
 294                     || errno == EROFS)
 295                  ? _("creating hard link %s")
 296                  : _("creating hard link %s => %s"))),
 297              quote_n (0, dest), quote_n (1, source));
 298
 299       if (dest_backup)
 300         {
 301           if (rename (dest_backup, dest) != 0)
 302             error (0, errno, _("cannot un-backup %s"), quote (dest));
 303         }
 304     }
 305
 306   free (dest_backup);
 307   return ok;
 308 }
 309
 310 void
 311 usage (int status)
 312 {
 313   if (status != EXIT_SUCCESS)
 314     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 315              program_name);
 316   else
 317     {
 318       printf (_("\
 319 Usage: %s [OPTION]... [-T] TARGET LINK_NAME   (1st form)\n\
 320   or:  %s [OPTION]... TARGET                  (2nd form)\n\
 321   or:  %s [OPTION]... TARGET... DIRECTORY     (3rd form)\n\
 322   or:  %s [OPTION]... -t DIRECTORY TARGET...  (4th form)\n\
 323 "),
 324               program_name, program_name, program_name, program_name);
 325       fputs (_("\
 326 In the 1st form, create a link to TARGET with the name LINK_NAME.\n\
 327 In the 2nd form, create a link to TARGET in the current directory.\n\
 328 In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.\n\
 329 Create hard links by default, symbolic links with --symbolic.\n\
 330 When creating hard links, each TARGET must exist.\n\
 331 \n\
 332 "), stdout);
 333       fputs (_("\
 334 Mandatory arguments to long options are mandatory for short options too.\n\
 335 "), stdout);
 336       fputs (_("\
 337       --backup[=CONTROL]      make a backup of each existing destination file\n\
 338   -b                          like --backup but does not accept an argument\n\
 339   -d, -F, --directory         allow the superuser to attempt to hard link\n\
 340                                 directories (note: will probably fail due to\n\
 341                                 system restrictions, even for the superuser)\n\
 342   -f, --force                 remove existing destination files\n\
 343 "), stdout);
 344       fputs (_("\
 345   -n, --no-dereference        treat destination that is a symlink to a\n\
 346                                 directory as if it were a normal file\n\
 347   -i, --interactive           prompt whether to remove destinations\n\
 348   -s, --symbolic              make symbolic links instead of hard links\n\
 349 "), stdout);
 350       fputs (_("\
 351   -S, --suffix=SUFFIX         override the usual backup suffix\n\
 352   -t, --target-directory=DIRECTORY  specify the DIRECTORY in which to create\n\
 353                                 the links\n\
 354   -T, --no-target-directory   treat LINK_NAME as a normal file\n\
 355   -v, --verbose               print name of each linked file\n\
 356 "), stdout);
 357       fputs (HELP_OPTION_DESCRIPTION, stdout);
 358       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 359       fputs (_("\
 360 \n\
 361 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 362 The version control method may be selected via the --backup option or through\n\
 363 the VERSION_CONTROL environment variable.  Here are the values:\n\
 364 \n\
 365 "), stdout);
 366       fputs (_("\
 367   none, off       never make backups (even if --backup is given)\n\
 368   numbered, t     make numbered backups\n\
 369   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 370   simple, never   always make simple backups\n\
 371 "), stdout);
 372       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 373     }
 374   exit (status);
 375 }
 376
 377 int
 378 main (int argc, char **argv)
 379 {
 380   int c;
 381   bool ok;
 382   bool make_backups = false;
 383   char *backup_suffix_string;
 384   char *version_control_string = NULL;
 385   char const *target_directory = NULL;
 386   bool no_target_directory = false;
 387   int n_files;
 388   char **file;
 389
 390   initialize_main (&argc, &argv);
 391   program_name = argv[0];
 392   setlocale (LC_ALL, "");
 393   bindtextdomain (PACKAGE, LOCALEDIR);
 394   textdomain (PACKAGE);
 395
 396   atexit (close_stdout);
 397
 398   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 399      we'll actually use backup_suffix_string.  */
 400   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 401
 402   symbolic_link = remove_existing_files = interactive = verbose
 403     = hard_dir_link = false;
 404
 405   while ((c = getopt_long (argc, argv, "bdfinst:vFS:T", long_options, NULL))
 406          != -1)
 407     {
 408       switch (c)
 409         {
 410         case 'b':
 411           make_backups = true;
 412           if (optarg)
 413             version_control_string = optarg;
 414           break;
 415         case 'd':
 416         case 'F':
 417           hard_dir_link = true;
 418           break;
 419         case 'f':
 420           remove_existing_files = true;
 421           interactive = false;
 422           break;
 423         case 'i':
 424           remove_existing_files = false;
 425           interactive = true;
 426           break;
 427         case 'n':
 428           dereference_dest_dir_symlinks = false;
 429           break;
 430         case 's':
 431           symbolic_link = true;
 432           break;
 433         case 't':
 434           if (target_directory)
 435             error (EXIT_FAILURE, 0, _("multiple target directories specified"));
 436           else
 437             {
 438               struct stat st;
 439               if (stat (optarg, &st) != 0)
 440                 error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg));
 441               if (! S_ISDIR (st.st_mode))
 442                 error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 443                        quote (optarg));
 444             }
 445           target_directory = optarg;
 446           break;
 447         case 'T':
 448           no_target_directory = true;
 449           break;
 450         case 'v':
 451           verbose = true;
 452           break;
 453         case 'S':
 454           make_backups = true;
 455           backup_suffix_string = optarg;
 456           break;
 457         case_GETOPT_HELP_CHAR;
 458         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 459         default:
 460           usage (EXIT_FAILURE);
 461           break;
 462         }
 463     }
 464
 465   n_files = argc - optind;
 466   file = argv + optind;
 467
 468   if (n_files <= 0)
 469     {
 470       error (0, 0, _("missing file operand"));
 471       usage (EXIT_FAILURE);
 472     }
 473
 474   if (no_target_directory)
 475     {
 476       if (target_directory)
 477         error (EXIT_FAILURE, 0,
 478                _("Cannot combine --target-directory "
 479                  "and --no-target-directory"));
 480       if (n_files != 2)
 481         {
 482           if (n_files < 2)
 483             error (0, 0,
 484                    _("missing destination file operand after %s"),
 485                    quote (file[0]));
 486           else
 487             error (0, 0, _("extra operand %s"), quote (file[2]));
 488           usage (EXIT_FAILURE);
 489         }
 490     }
 491   else if (!target_directory)
 492     {
 493       if (n_files < 2)
 494         target_directory = ".";
 495       else if (2 <= n_files && target_directory_operand (file[n_files - 1]))
 496         target_directory = file[--n_files];
 497       else if (2 < n_files)
 498         error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 499                quote (file[n_files - 1]));
 500     }
 501
 502   if (backup_suffix_string)
 503     simple_backup_suffix = xstrdup (backup_suffix_string);
 504
 505   backup_type = (make_backups
 506                  ? xget_version (_("backup type"), version_control_string)
 507                  : no_backups);
 508
 509   if (target_directory)
 510     {
 511       int i;
 512       ok = true;
 513       for (i = 0; i < n_files; ++i)
 514         {
 515           char *dest_base;
 516           char *dest = file_name_concat (target_directory,
 517                                          last_component (file[i]),
 518                                          &dest_base);
 519           strip_trailing_slashes (dest_base);
 520           ok &= do_link (file[i], dest);
 521           free (dest);
 522         }
 523     }
 524   else
 525     ok = do_link (file[0], file[1]);
 526
 527   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 528 }