1 /* install - copy files and set attributes
2 Copyright (C) 1989-2023 Free Software Foundation, Inc.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
22 #include <sys/types.h>
26 #include <selinux/label.h>
30 #include "backupfile.h"
35 #include "filenamecat.h"
36 #include "full-read.h"
37 #include "mkancesdirs.h"
39 #include "modechange.h"
40 #include "prog-fprintf.h"
44 #include "stat-time.h"
45 #include "targetdir.h"
49 /* The official name of this program (e.g., no 'g' prefix). */
50 #define PROGRAM_NAME "install"
52 #define AUTHORS proper_name ("David MacKenzie")
54 static int selinux_enabled
= 0;
55 static bool use_default_selinux_context
= true;
58 # define endgrent() ((void) 0)
62 # define endpwent() ((void) 0)
65 /* The user name that will own the files, or NULL to make the owner
66 the current user ID. */
67 static char *owner_name
;
69 /* The user ID corresponding to 'owner_name'. */
70 static uid_t owner_id
;
72 /* The group name that will own the files, or NULL to make the group
73 the current group ID. */
74 static char *group_name
;
76 /* The group ID corresponding to 'group_name'. */
77 static gid_t group_id
;
79 #define DEFAULT_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
81 /* The file mode bits to which non-directory files will be set. The umask has
83 static mode_t mode
= DEFAULT_MODE
;
85 /* Similar, but for directories. */
86 static mode_t dir_mode
= DEFAULT_MODE
;
88 /* The file mode bits that the user cares about. This should be a
89 superset of DIR_MODE and a subset of CHMOD_MODE_BITS. This matters
90 for directories, since otherwise directories may keep their S_ISUID
92 static mode_t dir_mode_bits
= CHMOD_MODE_BITS
;
94 /* Compare files before installing (-C) */
95 static bool copy_only_if_needed
;
97 /* If true, strip executable files after copying them. */
98 static bool strip_files
;
100 /* If true, install a directory instead of a regular file. */
103 /* Program used to strip binaries, "strip" is default */
104 static char const *strip_program
= "strip";
106 /* For long options that have no equivalent short option, use a
107 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
110 DEBUG_OPTION
= CHAR_MAX
+ 1,
111 PRESERVE_CONTEXT_OPTION
,
115 static struct option
const long_options
[] =
117 {"backup", optional_argument
, NULL
, 'b'},
118 {"compare", no_argument
, NULL
, 'C'},
119 {GETOPT_SELINUX_CONTEXT_OPTION_DECL
},
120 {"debug", no_argument
, NULL
, DEBUG_OPTION
},
121 {"directory", no_argument
, NULL
, 'd'},
122 {"group", required_argument
, NULL
, 'g'},
123 {"mode", required_argument
, NULL
, 'm'},
124 {"no-target-directory", no_argument
, NULL
, 'T'},
125 {"owner", required_argument
, NULL
, 'o'},
126 {"preserve-timestamps", no_argument
, NULL
, 'p'},
127 {"preserve-context", no_argument
, NULL
, PRESERVE_CONTEXT_OPTION
},
128 {"strip", no_argument
, NULL
, 's'},
129 {"strip-program", required_argument
, NULL
, STRIP_PROGRAM_OPTION
},
130 {"suffix", required_argument
, NULL
, 'S'},
131 {"target-directory", required_argument
, NULL
, 't'},
132 {"verbose", no_argument
, NULL
, 'v'},
133 {GETOPT_HELP_OPTION_DECL
},
134 {GETOPT_VERSION_OPTION_DECL
},
138 /* Compare content of opened files using file descriptors A_FD and B_FD. Return
139 true if files are equal. */
141 have_same_content (int a_fd
, int b_fd
)
143 enum { CMP_BLOCK_SIZE
= 4096 };
144 static char a_buff
[CMP_BLOCK_SIZE
];
145 static char b_buff
[CMP_BLOCK_SIZE
];
148 while (0 < (size
= full_read (a_fd
, a_buff
, sizeof a_buff
))) {
149 if (size
!= full_read (b_fd
, b_buff
, sizeof b_buff
))
152 if (memcmp (a_buff
, b_buff
, size
) != 0)
159 /* Return true for mode with non-permission bits. */
161 extra_mode (mode_t input
)
163 mode_t mask
= S_IRWXUGO
| S_IFMT
;
164 return !! (input
& ~ mask
);
167 /* Return true if copy of file SRC_NAME to file DEST_NAME aka
168 DEST_DIRFD+DEST_RELNAME is necessary. */
170 need_copy (char const *src_name
, char const *dest_name
,
171 int dest_dirfd
, char const *dest_relname
,
172 const struct cp_options
*x
)
174 struct stat src_sb
, dest_sb
;
178 if (extra_mode (mode
))
181 /* compare files using stat */
182 if (lstat (src_name
, &src_sb
) != 0)
185 if (fstatat (dest_dirfd
, dest_relname
, &dest_sb
, AT_SYMLINK_NOFOLLOW
) != 0)
188 if (!S_ISREG (src_sb
.st_mode
) || !S_ISREG (dest_sb
.st_mode
)
189 || extra_mode (src_sb
.st_mode
) || extra_mode (dest_sb
.st_mode
))
192 if (src_sb
.st_size
!= dest_sb
.st_size
193 || (dest_sb
.st_mode
& CHMOD_MODE_BITS
) != mode
)
196 if (owner_id
== (uid_t
) -1)
199 uid_t ruid
= getuid ();
200 if ((ruid
== (uid_t
) -1 && errno
) || dest_sb
.st_uid
!= ruid
)
203 else if (dest_sb
.st_uid
!= owner_id
)
206 if (group_id
== (uid_t
) -1)
209 gid_t rgid
= getgid ();
210 if ((rgid
== (uid_t
) -1 && errno
) || dest_sb
.st_gid
!= rgid
)
213 else if (dest_sb
.st_gid
!= group_id
)
216 /* compare SELinux context if preserving */
217 if (selinux_enabled
&& x
->preserve_security_context
)
219 char *file_scontext
= NULL
;
220 char *to_scontext
= NULL
;
223 if (getfilecon (src_name
, &file_scontext
) == -1)
226 if (getfilecon (dest_name
, &to_scontext
) == -1)
228 freecon (file_scontext
);
232 scontext_match
= STREQ (file_scontext
, to_scontext
);
234 freecon (file_scontext
);
235 freecon (to_scontext
);
240 /* compare files content */
241 src_fd
= open (src_name
, O_RDONLY
| O_BINARY
);
245 dest_fd
= openat (dest_dirfd
, dest_relname
, O_RDONLY
| O_BINARY
);
252 content_match
= have_same_content (src_fd
, dest_fd
);
256 return !content_match
;
260 cp_option_init (struct cp_options
*x
)
262 cp_options_default (x
);
263 x
->copy_as_regular
= true;
264 x
->reflink_mode
= REFLINK_AUTO
;
265 x
->dereference
= DEREF_ALWAYS
;
266 x
->unlink_dest_before_opening
= true;
267 x
->unlink_dest_after_failed_open
= false;
268 x
->hard_link
= false;
269 x
->interactive
= I_UNSPECIFIED
;
270 x
->move_mode
= false;
271 x
->install_mode
= true;
272 x
->one_file_system
= false;
273 x
->preserve_ownership
= false;
274 x
->preserve_links
= false;
275 x
->preserve_mode
= false;
276 x
->preserve_timestamps
= false;
277 x
->explicit_no_preserve_mode
= false;
278 x
->reduce_diagnostics
=false;
279 x
->data_copy_required
= true;
280 x
->require_preserve
= false;
281 x
->require_preserve_xattr
= false;
282 x
->recursive
= false;
283 x
->sparse_mode
= SPARSE_AUTO
;
284 x
->symbolic_link
= false;
285 x
->backup_type
= no_backups
;
287 /* Create destination files initially writable so we can run strip on them.
288 Although GNU strip works fine on read-only files, some others
291 x
->mode
= S_IRUSR
| S_IWUSR
;
292 x
->stdin_tty
= false;
294 x
->open_dangling_dest_symlink
= false;
296 x
->require_preserve_context
= false; /* Not used by install currently. */
297 x
->preserve_security_context
= false; /* Whether to copy context from src. */
298 x
->set_security_context
= NULL
; /* Whether to set sys default context. */
299 x
->preserve_xattr
= false;
305 static struct selabel_handle
*
306 get_labeling_handle (void)
308 static bool initialized
;
309 static struct selabel_handle
*hnd
;
313 hnd
= selabel_open (SELABEL_CTX_FILE
, NULL
, 0);
315 error (0, errno
, _("warning: security labeling handle failed"));
320 /* Modify file context to match the specified policy.
321 If an error occurs the file will remain with the default directory
322 context. Note this sets the context to that returned by selabel_lookup
323 and thus discards MLS levels and user identity of the FILE. */
325 setdefaultfilecon (char const *file
)
328 char *scontext
= NULL
;
330 if (selinux_enabled
!= 1)
332 /* Indicate no context found. */
335 if (lstat (file
, &st
) != 0)
338 struct selabel_handle
*hnd
= get_labeling_handle ();
341 if (selabel_lookup (hnd
, &scontext
, file
, st
.st_mode
) != 0)
343 if (errno
!= ENOENT
&& ! ignorable_ctx_err (errno
))
344 error (0, errno
, _("warning: %s: context lookup failed"),
349 if (lsetfilecon (file
, scontext
) < 0 && errno
!= ENOTSUP
)
351 _("warning: %s: failed to change context to %s"),
352 quotef_n (0, file
), quote_n (1, scontext
));
357 /* Report that directory DIR was made, if OPTIONS requests this. */
359 announce_mkdir (char const *dir
, void *options
)
361 struct cp_options
const *x
= options
;
363 prog_fprintf (stdout
, _("creating directory %s"), quoteaf (dir
));
366 /* Make ancestor directory DIR, whose last file name component is
367 COMPONENT, with options OPTIONS. Assume the working directory is
368 COMPONENT's parent. */
370 make_ancestor (char const *dir
, char const *component
, void *options
)
372 struct cp_options
const *x
= options
;
373 if (x
->set_security_context
374 && defaultcon (x
->set_security_context
, component
, S_IFDIR
) < 0
375 && ! ignorable_ctx_err (errno
))
376 error (0, errno
, _("failed to set default creation context for %s"),
379 int r
= mkdir (component
, DEFAULT_MODE
);
381 announce_mkdir (dir
, options
);
385 /* Process a command-line file name, for the -d option. */
387 process_dir (char *dir
, struct savewd
*wd
, void *options
)
389 struct cp_options
const *x
= options
;
391 int ret
= (make_dir_parents (dir
, wd
, make_ancestor
, options
,
392 dir_mode
, announce_mkdir
,
393 dir_mode_bits
, owner_id
, group_id
, false)
397 /* FIXME: Due to the current structure of make_dir_parents()
398 we don't have the facility to call defaultcon() before the
399 final component of DIR is created. So for now, create the
400 final component with the context from previous component
401 and here we set the context for the final component. */
402 if (ret
== EXIT_SUCCESS
&& x
->set_security_context
)
404 if (! restorecon (x
->set_security_context
, last_component (dir
), false)
405 && ! ignorable_ctx_err (errno
))
406 error (0, errno
, _("failed to restore context for %s"),
413 /* Copy file FROM onto file TO aka TO_DIRFD+TO_RELNAME, creating TO if
414 necessary. Return true if successful. */
417 copy_file (char const *from
, char const *to
,
418 int to_dirfd
, char const *to_relname
, const struct cp_options
*x
)
422 if (copy_only_if_needed
&& !need_copy (from
, to
, to_dirfd
, to_relname
, x
))
425 /* Allow installing from non-regular files like /dev/null.
426 Charles Karney reported that some Sun version of install allows that
427 and that sendmail's installation process relies on the behavior.
428 However, since !x->recursive, the call to "copy" will fail if FROM
431 return copy (from
, to
, to_dirfd
, to_relname
, 0, x
, ©_into_self
, NULL
);
434 /* Set the attributes of file or directory NAME aka DIRFD+RELNAME.
435 Return true if successful. */
438 change_attributes (char const *name
, int dirfd
, char const *relname
)
441 /* chown must precede chmod because on some systems,
442 chown clears the set[ug]id bits for non-superusers,
443 resulting in incorrect permissions.
444 On System V, users can give away files with chown and then not
445 be able to chmod them. So don't give files away.
447 We don't normally ignore errors from chown because the idea of
448 the install command is that the file is supposed to end up with
449 precisely the attributes that the user specified (or defaulted).
450 If the file doesn't end up with the group they asked for, they'll
453 if (! (owner_id
== (uid_t
) -1 && group_id
== (gid_t
) -1)
454 && lchownat (dirfd
, relname
, owner_id
, group_id
) != 0)
455 error (0, errno
, _("cannot change ownership of %s"), quoteaf (name
));
456 else if (chmodat (dirfd
, relname
, mode
) != 0)
457 error (0, errno
, _("cannot change permissions of %s"), quoteaf (name
));
461 if (use_default_selinux_context
)
462 setdefaultfilecon (name
);
467 /* Set the timestamps of file DEST aka DIRFD+RELNAME to match those of SRC_SB.
468 Return true if successful. */
471 change_timestamps (struct stat
const *src_sb
, char const *dest
,
472 int dirfd
, char const *relname
)
474 struct timespec timespec
[2];
475 timespec
[0] = get_stat_atime (src_sb
);
476 timespec
[1] = get_stat_mtime (src_sb
);
478 if (utimensat (dirfd
, relname
, timespec
, 0))
480 error (0, errno
, _("cannot set timestamps for %s"), quoteaf (dest
));
486 /* Strip the symbol table from the file NAME.
487 We could dig the magic number out of the file first to
488 determine whether to strip it, but the header files and
489 magic numbers vary so much from system to system that making
490 it portable would be very difficult. Not worth the effort. */
493 strip (char const *name
)
502 error (0, errno
, _("fork system call failed"));
505 execlp (strip_program
, strip_program
, name
, NULL
);
506 die (EXIT_FAILURE
, errno
, _("cannot run %s"), quoteaf (strip_program
));
507 default: /* Parent. */
508 if (waitpid (pid
, &status
, 0) < 0)
509 error (0, errno
, _("waiting for strip"));
510 else if (! WIFEXITED (status
) || WEXITSTATUS (status
))
511 error (0, 0, _("strip process terminated abnormally"));
513 ok
= true; /* strip succeeded */
519 /* Initialize the user and group ownership of the files to install. */
529 pw
= getpwnam (owner_name
);
533 if (xstrtoumax (owner_name
, NULL
, 0, &tmp
, "") != LONGINT_OK
535 die (EXIT_FAILURE
, 0, _("invalid user %s"),
540 owner_id
= pw
->pw_uid
;
544 owner_id
= (uid_t
) -1;
548 gr
= getgrnam (group_name
);
552 if (xstrtoumax (group_name
, NULL
, 0, &tmp
, "") != LONGINT_OK
554 die (EXIT_FAILURE
, 0, _("invalid group %s"),
559 group_id
= gr
->gr_gid
;
563 group_id
= (gid_t
) -1;
569 if (status
!= EXIT_SUCCESS
)
574 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
575 or: %s [OPTION]... SOURCE... DIRECTORY\n\
576 or: %s [OPTION]... -t DIRECTORY SOURCE...\n\
577 or: %s [OPTION]... -d DIRECTORY...\n\
579 program_name
, program_name
, program_name
, program_name
);
582 This install program copies files (often just compiled) into destination\n\
583 locations you choose. If you want to download and install a ready-to-use\n\
584 package on a GNU/Linux system, you should instead be using a package manager\n\
585 like yum(1) or apt-get(1).\n\
587 In the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\n\
588 the existing DIRECTORY, while setting permission modes and owner/group.\n\
589 In the 4th form, create all components of the given DIRECTORY(ies).\n\
592 emit_mandatory_arg_note ();
595 --backup[=CONTROL] make a backup of each existing destination file\n\
596 -b like --backup but does not accept an argument\n\
598 -C, --compare compare content of source and destination files, and\n\
599 if no change to content, ownership, and permissions,\n\
600 do not modify the destination at all\n\
601 -d, --directory treat all arguments as directory names; create all\n\
602 components of the specified directories\n\
605 -D create all leading components of DEST except the last,\n\
606 or all components of --target-directory,\n\
607 then copy SOURCE to DEST\n\
610 --debug explain how a file is copied. Implies -v\n\
613 -g, --group=GROUP set group ownership, instead of process' current group\n\
614 -m, --mode=MODE set permission mode (as in chmod), instead of rwxr-xr-x\n\
615 -o, --owner=OWNER set ownership (super-user only)\n\
618 -p, --preserve-timestamps apply access/modification times of SOURCE files\n\
619 to corresponding destination files\n\
620 -s, --strip strip symbol tables\n\
621 --strip-program=PROGRAM program used to strip binaries\n\
622 -S, --suffix=SUFFIX override the usual backup suffix\n\
623 -t, --target-directory=DIRECTORY copy all SOURCE arguments into DIRECTORY\n\
624 -T, --no-target-directory treat DEST as a normal file\n\
627 -v, --verbose print the name of each created file or directory\n\
630 --preserve-context preserve SELinux security context\n\
631 -Z set SELinux security context of destination\n\
632 file and each created directory to default type\n\
633 --context[=CTX] like -Z, or if CTX is specified then set the\n\
634 SELinux or SMACK security context to CTX\n\
637 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
638 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
639 emit_backup_suffix_note ();
640 emit_ancillary_info (PROGRAM_NAME
);
645 /* Copy file FROM onto file TO aka TO_DIRFD+TO_RELNAME and give TO the
646 appropriate attributes. X gives the command options.
647 Return true if successful. */
650 install_file_in_file (char const *from
, char const *to
,
651 int to_dirfd
, char const *to_relname
,
652 const struct cp_options
*x
)
655 if (x
->preserve_timestamps
&& stat (from
, &from_sb
) != 0)
657 error (0, errno
, _("cannot stat %s"), quoteaf (from
));
660 if (! copy_file (from
, to
, to_dirfd
, to_relname
, x
))
665 if (unlinkat (to_dirfd
, to_relname
, 0) != 0) /* Cleanup. */
666 die (EXIT_FAILURE
, errno
, _("cannot unlink %s"), quoteaf (to
));
669 if (x
->preserve_timestamps
&& (strip_files
|| ! S_ISREG (from_sb
.st_mode
))
670 && ! change_timestamps (&from_sb
, to
, to_dirfd
, to_relname
))
672 return change_attributes (to
, to_dirfd
, to_relname
);
675 /* Create any missing parent directories of TO,
676 while maintaining the current Working Directory.
677 Return true if successful. */
680 mkancesdirs_safe_wd (char const *from
, char *to
, struct cp_options
*x
,
683 bool save_working_directory
=
685 || ! (IS_ABSOLUTE_FILE_NAME (from
) && IS_ABSOLUTE_FILE_NAME (to
));
686 int status
= EXIT_SUCCESS
;
690 if (! save_working_directory
)
693 if (mkancesdirs (to
, &wd
, make_ancestor
, x
) == -1)
695 error (0, errno
, _("cannot create directory %s"), quoteaf (to
));
696 status
= EXIT_FAILURE
;
699 if (save_working_directory
)
701 int restore_result
= savewd_restore (&wd
, status
);
702 int restore_errno
= errno
;
704 if (EXIT_SUCCESS
< restore_result
)
706 if (restore_result
< 0 && status
== EXIT_SUCCESS
)
708 error (0, restore_errno
, _("cannot create directory %s"),
713 return status
== EXIT_SUCCESS
;
716 /* Copy file FROM onto file TO, creating any missing parent directories of TO.
717 Return true if successful. */
720 install_file_in_file_parents (char const *from
, char *to
,
721 const struct cp_options
*x
)
723 return (mkancesdirs_safe_wd (from
, to
, (struct cp_options
*)x
, false)
724 && install_file_in_file (from
, to
, AT_FDCWD
, to
, x
));
727 /* Copy file FROM into directory TO_DIR, keeping its same name,
728 and give the copy the appropriate attributes.
729 Return true if successful. */
732 install_file_in_dir (char const *from
, char const *to_dir
,
733 const struct cp_options
*x
, bool mkdir_and_install
,
736 char const *from_base
= last_component (from
);
738 char *to
= file_name_concat (to_dir
, from_base
, &to_relname
);
741 if (!target_dirfd_valid (*target_dirfd
)
742 && (ret
= mkdir_and_install
)
743 && (ret
= mkancesdirs_safe_wd (from
, to
, (struct cp_options
*) x
, true)))
745 int fd
= open (to_dir
, O_PATHSEARCH
| O_DIRECTORY
);
748 error (0, errno
, _("cannot open %s"), quoteaf (to
));
757 int to_dirfd
= *target_dirfd
;
758 if (!target_dirfd_valid (to_dirfd
))
763 ret
= install_file_in_file (from
, to
, to_dirfd
, to_relname
, x
);
771 main (int argc
, char **argv
)
774 int exit_status
= EXIT_SUCCESS
;
775 char const *specified_mode
= NULL
;
776 bool make_backups
= false;
777 char const *backup_suffix
= NULL
;
778 char *version_control_string
= NULL
;
779 bool mkdir_and_install
= false;
781 char const *target_directory
= NULL
;
782 bool no_target_directory
= false;
785 bool strip_program_specified
= false;
786 char const *scontext
= NULL
;
787 /* set iff kernel has extra selinux system calls */
788 selinux_enabled
= (0 < is_selinux_enabled ());
790 initialize_main (&argc
, &argv
);
791 set_program_name (argv
[0]);
792 setlocale (LC_ALL
, "");
793 bindtextdomain (PACKAGE
, LOCALEDIR
);
794 textdomain (PACKAGE
);
796 atexit (close_stdin
);
806 while ((optc
= getopt_long (argc
, argv
, "bcCsDdg:m:o:pt:TvS:Z", long_options
,
814 version_control_string
= optarg
;
819 copy_only_if_needed
= true;
824 /* System V fork+wait does not work if SIGCHLD is ignored. */
825 signal (SIGCHLD
, SIG_DFL
);
829 x
.debug
= x
.verbose
= true;
831 case STRIP_PROGRAM_OPTION
:
832 strip_program
= xstrdup (optarg
);
833 strip_program_specified
= true;
839 mkdir_and_install
= true;
848 specified_mode
= optarg
;
854 x
.preserve_timestamps
= true;
858 backup_suffix
= optarg
;
861 if (target_directory
)
862 die (EXIT_FAILURE
, 0,
863 _("multiple target directories specified"));
864 target_directory
= optarg
;
867 no_target_directory
= true;
870 case PRESERVE_CONTEXT_OPTION
:
871 if (! selinux_enabled
)
873 error (0, 0, _("WARNING: ignoring --preserve-context; "
874 "this kernel is not SELinux-enabled"));
877 x
.preserve_security_context
= true;
878 use_default_selinux_context
= false;
883 /* Disable use of the install(1) specific setdefaultfilecon().
884 Note setdefaultfilecon() is different from the newer and more
885 generic restorecon() in that the former sets the context of
886 the dest files to that returned by selabel_lookup directly,
887 thus discarding MLS level and user identity of the file.
888 TODO: consider removing setdefaultfilecon() in future. */
889 use_default_selinux_context
= false;
894 x
.set_security_context
= get_labeling_handle ();
899 _("warning: ignoring --context; "
900 "it requires an SELinux-enabled kernel"));
903 case_GETOPT_HELP_CHAR
;
904 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
906 usage (EXIT_FAILURE
);
910 /* Check for invalid combinations of arguments. */
911 if (dir_arg
&& strip_files
)
912 die (EXIT_FAILURE
, 0,
913 _("the strip option may not be used when installing a directory"));
914 if (dir_arg
&& target_directory
)
915 die (EXIT_FAILURE
, 0,
916 _("target directory not allowed when installing a directory"));
918 x
.backup_type
= (make_backups
919 ? xget_version (_("backup type"),
920 version_control_string
)
922 set_simple_backup_suffix (backup_suffix
);
924 if (x
.preserve_security_context
&& (x
.set_security_context
|| scontext
))
925 die (EXIT_FAILURE
, 0,
926 _("cannot set target context and preserve it"));
928 if (scontext
&& setfscreatecon (scontext
) < 0)
929 die (EXIT_FAILURE
, errno
,
930 _("failed to set default file creation context to %s"),
933 n_files
= argc
- optind
;
934 file
= argv
+ optind
;
936 if (n_files
<= ! (dir_arg
|| target_directory
))
939 error (0, 0, _("missing file operand"));
941 error (0, 0, _("missing destination file operand after %s"),
943 usage (EXIT_FAILURE
);
947 int target_dirfd
= AT_FDCWD
;
948 if (no_target_directory
)
950 if (target_directory
)
951 die (EXIT_FAILURE
, 0,
952 _("cannot combine --target-directory (-t) "
953 "and --no-target-directory (-T)"));
956 error (0, 0, _("extra operand %s"), quoteaf (file
[2]));
957 usage (EXIT_FAILURE
);
960 else if (target_directory
)
962 target_dirfd
= target_directory_operand (target_directory
, &sb
);
963 if (! (target_dirfd_valid (target_dirfd
)
964 || (mkdir_and_install
&& errno
== ENOENT
)))
965 die (EXIT_FAILURE
, errno
, _("failed to access %s"),
966 quoteaf (target_directory
));
970 char const *lastfile
= file
[n_files
- 1];
971 int fd
= target_directory_operand (lastfile
, &sb
);
972 if (target_dirfd_valid (fd
))
975 target_directory
= lastfile
;
978 else if (2 < n_files
)
979 die (EXIT_FAILURE
, errno
, _("target %s"), quoteaf (lastfile
));
984 struct mode_change
*change
= mode_compile (specified_mode
);
986 die (EXIT_FAILURE
, 0, _("invalid mode %s"), quote (specified_mode
));
987 mode
= mode_adjust (0, false, 0, change
, NULL
);
988 dir_mode
= mode_adjust (0, true, 0, change
, &dir_mode_bits
);
992 if (strip_program_specified
&& !strip_files
)
993 error (0, 0, _("WARNING: ignoring --strip-program option as -s option was "
996 if (copy_only_if_needed
&& x
.preserve_timestamps
)
998 error (0, 0, _("options --compare (-C) and --preserve-timestamps are "
999 "mutually exclusive"));
1000 usage (EXIT_FAILURE
);
1003 if (copy_only_if_needed
&& strip_files
)
1005 error (0, 0, _("options --compare (-C) and --strip are mutually "
1007 usage (EXIT_FAILURE
);
1010 if (copy_only_if_needed
&& extra_mode (mode
))
1011 error (0, 0, _("the --compare (-C) option is ignored when you"
1012 " specify a mode with non-permission bits"));
1017 exit_status
= savewd_process_files (n_files
, file
, process_dir
, &x
);
1020 /* FIXME: it's a little gross that this initialization is
1021 required by copy.c::copy. */
1024 if (!target_directory
)
1026 if (! (mkdir_and_install
1027 ? install_file_in_file_parents (file
[0], file
[1], &x
)
1028 : install_file_in_file (file
[0], file
[1], AT_FDCWD
,
1030 exit_status
= EXIT_FAILURE
;
1035 dest_info_init (&x
);
1036 for (i
= 0; i
< n_files
; i
++)
1037 if (! install_file_in_dir (file
[i
], target_directory
, &x
,
1038 i
== 0 && mkdir_and_install
,
1040 exit_status
= EXIT_FAILURE
;
1044 main_exit (exit_status
);