1/* `ln' program to create links between files. 2 Copyright (C) 1986, 1989-1991, 1995-2010 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 3 of the License, or 7 (at your option) 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, see <http://www.gnu.org/licenses/>. */ 16 17/* Written by Mike Parker and David MacKenzie. */ 18 19#include <config.h> 20#include <stdio.h> 21#include <sys/types.h> 22#include <getopt.h> 23 24#include "system.h" 25#include "backupfile.h" 26#include "error.h" 27#include "filenamecat.h" 28#include "file-set.h" 29#include "hash.h" 30#include "hash-triple.h" 31#include "quote.h" 32#include "same.h" 33#include "yesno.h" 34 35/* The official name of this program (e.g., no `g' prefix). */ 36#define PROGRAM_NAME "ln" 37 38#define AUTHORS \ 39 proper_name ("Mike Parker"), \ 40 proper_name ("David MacKenzie") 41 42/* FIXME: document */ 43static enum backup_type backup_type; 44 45/* If true, make symbolic links; otherwise, make hard links. */ 46static bool symbolic_link; 47 48/* If true, hard links are logical rather than physical. */ 49static bool logical = !!LINK_FOLLOWS_SYMLINKS; 50 51/* If true, ask the user before removing existing files. */ 52static bool interactive; 53 54/* If true, remove existing files unconditionally. */ 55static bool remove_existing_files; 56 57/* If true, list each file as it is moved. */ 58static bool verbose; 59 60/* If true, allow the superuser to *attempt* to make hard links 61 to directories. However, it appears that this option is not useful 62 in practice, since even the superuser is prohibited from hard-linking 63 directories on most existing systems (Solaris being an exception). */ 64static bool hard_dir_link; 65 66/* If nonzero, and the specified destination is a symbolic link to a 67 directory, treat it just as if it were a directory. Otherwise, the 68 command `ln --force --no-dereference file symlink-to-dir' deletes 69 symlink-to-dir before creating the new link. */ 70static bool dereference_dest_dir_symlinks = true; 71 72/* This is a set of destination name/inode/dev triples for hard links 73 created by ln. Use this data structure to avoid data loss via a 74 sequence of commands like this: 75 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 */ 76static Hash_table *dest_set; 77 78/* Initial size of the dest_set hash table. */ 79enum { DEST_INFO_INITIAL_CAPACITY = 61 }; 80 81static struct option const long_options[] = 82{ 83 {"backup", optional_argument, NULL, 'b'}, 84 {"directory", no_argument, NULL, 'F'}, 85 {"no-dereference", no_argument, NULL, 'n'}, 86 {"no-target-directory", no_argument, NULL, 'T'}, 87 {"force", no_argument, NULL, 'f'}, 88 {"interactive", no_argument, NULL, 'i'}, 89 {"suffix", required_argument, NULL, 'S'}, 90 {"target-directory", required_argument, NULL, 't'}, 91 {"logical", no_argument, NULL, 'L'}, 92 {"physical", no_argument, NULL, 'P'}, 93 {"symbolic", no_argument, NULL, 's'}, 94 {"verbose", no_argument, NULL, 'v'}, 95 {GETOPT_HELP_OPTION_DECL}, 96 {GETOPT_VERSION_OPTION_DECL}, 97 {NULL, 0, NULL, 0} 98}; 99 100/* FILE is the last operand of this command. Return true if FILE is a 101 directory. But report an error there is a problem accessing FILE, 102 or if FILE does not exist but would have to refer to an existing 103 directory if it referred to anything at all. */ 104 105static bool 106target_directory_operand (char const *file) 107{ 108 char const *b = last_component (file); 109 size_t blen = strlen (b); 110 bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1])); 111 struct stat st; 112 int stat_result = 113 (dereference_dest_dir_symlinks ? stat (file, &st) : lstat (file, &st)); 114 int err = (stat_result == 0 ? 0 : errno); 115 bool is_a_dir = !err && S_ISDIR (st.st_mode); 116 if (err && err != ENOENT) 117 error (EXIT_FAILURE, err, _("accessing %s"), quote (file)); 118 if (is_a_dir < looks_like_a_dir) 119 error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file)); 120 return is_a_dir; 121} 122 123/* Make a link DEST to the (usually) existing file SOURCE. 124 Symbolic links to nonexistent files are allowed. 125 Return true if successful. */ 126 127static bool 128do_link (const char *source, const char *dest) 129{ 130 struct stat source_stats; 131 struct stat dest_stats; 132 char *dest_backup = NULL; 133 bool dest_lstat_ok = false; 134 bool source_is_dir = false; 135 bool ok; 136 137 if (!symbolic_link) 138 { 139 /* Which stat to use depends on whether linkat will follow the 140 symlink. We can't use the shorter 141 (logical?stat:lstat) (source, &source_stats) 142 since stat might be a function-like macro. */ 143 if ((logical ? stat (source, &source_stats) 144 : lstat (source, &source_stats)) 145 != 0) 146 { 147 error (0, errno, _("accessing %s"), quote (source)); 148 return false; 149 } 150 151 if (S_ISDIR (source_stats.st_mode)) 152 { 153 source_is_dir = true; 154 if (! hard_dir_link) 155 { 156 error (0, 0, _("%s: hard link not allowed for directory"), 157 quote (source)); 158 return false; 159 } 160 } 161 } 162 163 if (remove_existing_files || interactive || backup_type != no_backups) 164 { 165 dest_lstat_ok = (lstat (dest, &dest_stats) == 0); 166 if (!dest_lstat_ok && errno != ENOENT) 167 { 168 error (0, errno, _("accessing %s"), quote (dest)); 169 return false; 170 } 171 } 172 173 /* If the current target was created as a hard link to another 174 source file, then refuse to unlink it. */ 175 if (dest_lstat_ok 176 && dest_set != NULL 177 && seen_file (dest_set, dest, &dest_stats)) 178 { 179 error (0, 0, 180 _("will not overwrite just-created %s with %s"), 181 quote_n (0, dest), quote_n (1, source)); 182 return false; 183 } 184 185 /* If --force (-f) has been specified without --backup, then before 186 making a link ln must remove the destination file if it exists. 187 (with --backup, it just renames any existing destination file) 188 But if the source and destination are the same, don't remove 189 anything and fail right here. */ 190 if ((remove_existing_files 191 /* Ensure that "ln --backup f f" fails here, with the 192 "... same file" diagnostic, below. Otherwise, subsequent 193 code would give a misleading "file not found" diagnostic. 194 This case is different than the others handled here, since 195 the command in question doesn't use --force. */ 196 || (!symbolic_link && backup_type != no_backups)) 197 && dest_lstat_ok 198 /* Allow `ln -sf --backup k k' to succeed in creating the 199 self-referential symlink, but don't allow the hard-linking 200 equivalent: `ln -f k k' (with or without --backup) to get 201 beyond this point, because the error message you'd get is 202 misleading. */ 203 && (backup_type == no_backups || !symbolic_link) 204 && (!symbolic_link || stat (source, &source_stats) == 0) 205 && SAME_INODE (source_stats, dest_stats) 206 /* The following detects whether removing DEST will also remove 207 SOURCE. If the file has only one link then both are surely 208 the same link. Otherwise check whether they point to the same 209 name in the same directory. */ 210 && (source_stats.st_nlink == 1 || same_name (source, dest))) 211 { 212 error (0, 0, _("%s and %s are the same file"), 213 quote_n (0, source), quote_n (1, dest)); 214 return false; 215 } 216 217 if (dest_lstat_ok) 218 { 219 if (S_ISDIR (dest_stats.st_mode)) 220 { 221 error (0, 0, _("%s: cannot overwrite directory"), quote (dest)); 222 return false; 223 } 224 if (interactive) 225 { 226 fprintf (stderr, _("%s: replace %s? "), program_name, quote (dest)); 227 if (!yesno ()) 228 return true; 229 remove_existing_files = true; 230 } 231 232 if (backup_type != no_backups) 233 { 234 dest_backup = find_backup_file_name (dest, backup_type); 235 if (rename (dest, dest_backup) != 0) 236 { 237 int rename_errno = errno; 238 free (dest_backup); 239 dest_backup = NULL; 240 if (rename_errno != ENOENT) 241 { 242 error (0, rename_errno, _("cannot backup %s"), quote (dest)); 243 return false; 244 } 245 } 246 } 247 } 248 249 ok = ((symbolic_link ? symlink (source, dest) 250 : linkat (AT_FDCWD, source, AT_FDCWD, dest, 251 logical ? AT_SYMLINK_FOLLOW : 0)) 252 == 0); 253 254 /* If the attempt to create a link failed and we are removing or 255 backing up destinations, unlink the destination and try again. 256 257 On the surface, POSIX describes an algorithm that states that 258 'ln -f A B' will call unlink() on B before ever attempting 259 link() on A. But strictly following this has the counterintuitive 260 effect of losing the contents of B, if A does not exist. 261 Fortunately, POSIX 2008 clarified that an application is free 262 to fail early if it can prove that continuing onwards cannot 263 succeed, so we are justified in trying link() before blindly 264 removing B, thus sometimes calling link() a second time during 265 a successful 'ln -f A B'. 266 267 Try to unlink DEST even if we may have backed it up successfully. 268 In some unusual cases (when DEST and DEST_BACKUP are hard-links 269 that refer to the same file), rename succeeds and DEST remains. 270 If we didn't remove DEST in that case, the subsequent symlink or link 271 call would fail. */ 272 273 if (!ok && errno == EEXIST && (remove_existing_files || dest_backup)) 274 { 275 if (unlink (dest) != 0) 276 { 277 error (0, errno, _("cannot remove %s"), quote (dest)); 278 free (dest_backup); 279 return false; 280 } 281 282 ok = ((symbolic_link ? symlink (source, dest) 283 : linkat (AT_FDCWD, source, AT_FDCWD, dest, 284 logical ? AT_SYMLINK_FOLLOW : 0)) 285 == 0); 286 } 287 288 if (ok) 289 { 290 /* Right after creating a hard link, do this: (note dest name and 291 source_stats, which are also the just-linked-destinations stats) */ 292 record_file (dest_set, dest, &source_stats); 293 294 if (verbose) 295 { 296 if (dest_backup) 297 printf ("%s ~ ", quote (dest_backup)); 298 printf ("%s %c> %s\n", quote_n (0, dest), (symbolic_link ? '-' : '='), 299 quote_n (1, source)); 300 } 301 } 302 else 303 { 304 error (0, errno, 305 (symbolic_link 306 ? (errno != ENAMETOOLONG && *source 307 ? _("creating symbolic link %s") 308 : _("creating symbolic link %s -> %s")) 309 : (errno == EMLINK && !source_is_dir 310 ? _("creating hard link to %.0s%s") 311 : (errno == EDQUOT || errno == EEXIST || errno == ENOSPC 312 || errno == EROFS) 313 ? _("creating hard link %s") 314 : _("creating hard link %s => %s"))), 315 quote_n (0, dest), quote_n (1, source)); 316 317 if (dest_backup) 318 { 319 if (rename (dest_backup, dest) != 0) 320 error (0, errno, _("cannot un-backup %s"), quote (dest)); 321 } 322 } 323 324 free (dest_backup); 325 return ok; 326} 327 328void 329usage (int status) 330{ 331 if (status != EXIT_SUCCESS) 332 fprintf (stderr, _("Try `%s --help' for more information.\n"), 333 program_name); 334 else 335 { 336 printf (_("\ 337Usage: %s [OPTION]... [-T] TARGET LINK_NAME (1st form)\n\ 338 or: %s [OPTION]... TARGET (2nd form)\n\ 339 or: %s [OPTION]... TARGET... DIRECTORY (3rd form)\n\ 340 or: %s [OPTION]... -t DIRECTORY TARGET... (4th form)\n\ 341"), 342 program_name, program_name, program_name, program_name); 343 fputs (_("\ 344In the 1st form, create a link to TARGET with the name LINK_NAME.\n\ 345In the 2nd form, create a link to TARGET in the current directory.\n\ 346In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.\n\ 347Create hard links by default, symbolic links with --symbolic.\n\ 348When creating hard links, each TARGET must exist. Symbolic links\n\ 349can hold arbitrary text; if later resolved, a relative link is\n\ 350interpreted in relation to its parent directory.\n\ 351\n\ 352"), stdout); 353 fputs (_("\ 354Mandatory arguments to long options are mandatory for short options too.\n\ 355"), stdout); 356 fputs (_("\ 357 --backup[=CONTROL] make a backup of each existing destination file\n\ 358 -b like --backup but does not accept an argument\n\ 359 -d, -F, --directory allow the superuser to attempt to hard link\n\ 360 directories (note: will probably fail due to\n\ 361 system restrictions, even for the superuser)\n\ 362 -f, --force remove existing destination files\n\ 363"), stdout); 364 fputs (_("\ 365 -i, --interactive prompt whether to remove destinations\n\ 366 -L, --logical make hard links to symbolic link references\n\ 367 -n, --no-dereference treat destination that is a symlink to a\n\ 368 directory as if it were a normal file\n\ 369 -P, --physical make hard links directly to symbolic links\n\ 370 -s, --symbolic make symbolic links instead of hard links\n\ 371"), stdout); 372 fputs (_("\ 373 -S, --suffix=SUFFIX override the usual backup suffix\n\ 374 -t, --target-directory=DIRECTORY specify the DIRECTORY in which to create\n\ 375 the links\n\ 376 -T, --no-target-directory treat LINK_NAME as a normal file\n\ 377 -v, --verbose print name of each linked file\n\ 378"), stdout); 379 fputs (HELP_OPTION_DESCRIPTION, stdout); 380 fputs (VERSION_OPTION_DESCRIPTION, stdout); 381 fputs (_("\ 382\n\ 383The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\ 384The version control method may be selected via the --backup option or through\n\ 385the VERSION_CONTROL environment variable. Here are the values:\n\ 386\n\ 387"), stdout); 388 printf (_("\ 389Using -s ignores -L and -P. Otherwise, the last option specified controls\n\ 390behavior when the source is a symbolic link, defaulting to %s.\n\ 391\n\ 392"), LINK_FOLLOWS_SYMLINKS ? "-L" : "-P"); 393 fputs (_("\ 394 none, off never make backups (even if --backup is given)\n\ 395 numbered, t make numbered backups\n\ 396 existing, nil numbered if numbered backups exist, simple otherwise\n\ 397 simple, never always make simple backups\n\ 398"), stdout); 399 emit_ancillary_info (); 400 } 401 exit (status); 402} 403 404int 405main (int argc, char **argv) 406{ 407 int c; 408 bool ok; 409 bool make_backups = false; 410 char *backup_suffix_string; 411 char *version_control_string = NULL; 412 char const *target_directory = NULL; 413 bool no_target_directory = false; 414 int n_files; 415 char **file; 416 417 initialize_main (&argc, &argv); 418 set_program_name (argv[0]); 419 setlocale (LC_ALL, ""); 420 bindtextdomain (PACKAGE, LOCALEDIR); 421 textdomain (PACKAGE); 422 423 atexit (close_stdin); 424 425 /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless 426 we'll actually use backup_suffix_string. */ 427 backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX"); 428 429 symbolic_link = remove_existing_files = interactive = verbose 430 = hard_dir_link = false; 431 432 while ((c = getopt_long (argc, argv, "bdfinst:vFLPS:T", long_options, NULL)) 433 != -1) 434 { 435 switch (c) 436 { 437 case 'b': 438 make_backups = true; 439 if (optarg) 440 version_control_string = optarg; 441 break; 442 case 'd': 443 case 'F': 444 hard_dir_link = true; 445 break; 446 case 'f': 447 remove_existing_files = true; 448 interactive = false; 449 break; 450 case 'i': 451 remove_existing_files = false; 452 interactive = true; 453 break; 454 case 'L': 455 logical = true; 456 break; 457 case 'n': 458 dereference_dest_dir_symlinks = false; 459 break; 460 case 'P': 461 logical = false; 462 break; 463 case 's': 464 symbolic_link = true; 465 break; 466 case 't': 467 if (target_directory) 468 error (EXIT_FAILURE, 0, _("multiple target directories specified")); 469 else 470 { 471 struct stat st; 472 if (stat (optarg, &st) != 0) 473 error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg)); 474 if (! S_ISDIR (st.st_mode)) 475 error (EXIT_FAILURE, 0, _("target %s is not a directory"), 476 quote (optarg)); 477 } 478 target_directory = optarg; 479 break; 480 case 'T': 481 no_target_directory = true; 482 break; 483 case 'v': 484 verbose = true; 485 break; 486 case 'S': 487 make_backups = true; 488 backup_suffix_string = optarg; 489 break; 490 case_GETOPT_HELP_CHAR; 491 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); 492 default: 493 usage (EXIT_FAILURE); 494 break; 495 } 496 } 497 498 n_files = argc - optind; 499 file = argv + optind; 500 501 if (n_files <= 0) 502 { 503 error (0, 0, _("missing file operand")); 504 usage (EXIT_FAILURE); 505 } 506 507 if (no_target_directory) 508 { 509 if (target_directory) 510 error (EXIT_FAILURE, 0, 511 _("cannot combine --target-directory " 512 "and --no-target-directory")); 513 if (n_files != 2) 514 { 515 if (n_files < 2) 516 error (0, 0, 517 _("missing destination file operand after %s"), 518 quote (file[0])); 519 else 520 error (0, 0, _("extra operand %s"), quote (file[2])); 521 usage (EXIT_FAILURE); 522 } 523 } 524 else if (!target_directory) 525 { 526 if (n_files < 2) 527 target_directory = "."; 528 else if (2 <= n_files && target_directory_operand (file[n_files - 1])) 529 target_directory = file[--n_files]; 530 else if (2 < n_files) 531 error (EXIT_FAILURE, 0, _("target %s is not a directory"), 532 quote (file[n_files - 1])); 533 } 534 535 if (backup_suffix_string) 536 simple_backup_suffix = xstrdup (backup_suffix_string); 537 538 backup_type = (make_backups 539 ? xget_version (_("backup type"), version_control_string) 540 : no_backups); 541 542 if (target_directory) 543 { 544 int i; 545 546 /* Create the data structure we'll use to record which hard links we 547 create. Used to ensure that ln detects an obscure corner case that 548 might result in user data loss. Create it only if needed. */ 549 if (2 <= n_files 550 && remove_existing_files 551 /* Don't bother trying to protect symlinks, since ln clobbering 552 a just-created symlink won't ever lead to real data loss. */ 553 && ! symbolic_link 554 /* No destination hard link can be clobbered when making 555 numbered backups. */ 556 && backup_type != numbered_backups) 557 558 { 559 dest_set = hash_initialize (DEST_INFO_INITIAL_CAPACITY, 560 NULL, 561 triple_hash, 562 triple_compare, 563 triple_free); 564 if (dest_set == NULL) 565 xalloc_die (); 566 } 567 568 ok = true; 569 for (i = 0; i < n_files; ++i) 570 { 571 char *dest_base; 572 char *dest = file_name_concat (target_directory, 573 last_component (file[i]), 574 &dest_base); 575 strip_trailing_slashes (dest_base); 576 ok &= do_link (file[i], dest); 577 free (dest); 578 } 579 } 580 else 581 ok = do_link (file[0], file[1]); 582 583 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE); 584} 585