| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This chapter describes the commands for basic file manipulation: copying, moving (renaming), and deleting (removing).
11.1 cp: Copy files and directoriesCopy files. 11.2 dd: Convert and copy a fileConvert and copy a file. 11.3 install: Copy files and set attributesCopy files and set attributes. 11.4 mv: Move (rename) filesMove (rename) files. 11.5 rm: Remove files or directoriesRemove files or directories. 11.6 shred: Remove files more securelyRemove files more securely.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
cp: Copy files and directories
cp copies files (or, optionally, directories). The copy is
completely independent of the original. You can either copy one file to
another, or copy arbitrarily many files to a destination directory.
Synopsis:
cp [option]... source dest cp [option]... source... directory |
If the last argument names an existing directory, cp copies each
source file into that directory (retaining the same name).
Otherwise, if only two files are given, it copies the first onto the
second. It is an error if the last argument is not a directory and more
than two non-option arguments are given.
Generally, files are written just as they are read. For exceptions, see the `--sparse' option below.
By default, cp does not copy directories. However, the
`-R', `-a', and `-r' options cause cp to
copy recursively by descending into source directories and copying files
to corresponding destination directories.
By default, cp follows symbolic links only when not copying
recursively. This default can be overridden with the
`--archive' (`-a'), `-d', `--dereference'
(`-L'), `--no-dereference' (`-P'), and
`-H' options. If more than one of these options is specified,
the last one silently overrides the others.
By default, cp copies the contents of special files only
when not copying recursively. This default can be overridden with the
`--copy-contents' option.
cp generally refuses to copy a file onto itself, with the
following exception: if `--force --backup' is specified with
source and dest identical, and referring to a regular file,
cp will make a backup file, either regular or numbered, as
specified in the usual ways (see section 2.1 Backup options). This is useful when
you simply want to make a backup of an existing file before changing it.
The program accepts the following options. Also see 2. Common options.
cp makes a backup of source when the force
and backup options are given and source and dest are the same
name for an existing, regular file. One useful application of this
combination of options is this tiny Bourne shell script:
#!/bin/sh # Usage: backup FILE... # Create a GNU-style backup of each listed FILE. for i; do cp --backup --force "$i" "$i" done |
cp -R --copy-contents will hang indefinitely trying to read
from FIFOs and special files like `/dev/console', and it will
fill up your destination disk if you use it to copy `/dev/zero'.
This option has no effect unless copying recursively, and it does not
affect the copying of symbolic links.
cp then unlinks it and
tries to open it again. Contrast this behavior with that enabled by
`--link' and `--symbolic-link', whereby the destination file
is never opened but rather is unlinked unconditionally. Also see the
description of `--remove-destination'.
Using `--preserve' with no attribute_list is equivalent to `--preserve=mode,ownership,timestamps'.
In the absence of this option, each destination file is created with the permissions of the corresponding source file, minus the bits set in the umask and minus the set-user-id and set-group-id bits. See section 26. File permissions.
cp must be the name of an existing directory.
For example, the command:
cp --parents a/b/c existing_dir |
copies the file `a/b/c' to `existing_dir/a/b/c', creating any missing intermediate directories.
cp act as if `yes' were
given as a response to every prompt about a destination file. That effectively
cancels any preceding `--interactive' or `-i' option.
Specify `--reply=no' to make cp act as if `no' were
given as a response to every prompt about a destination file.
Specify `--reply=query' to make cp prompt the user
about each existing destination file.
cp detects holes in input source files via a crude
heuristic and makes the corresponding output file sparse as well.
The when value can be one of the following:
mkswap command,
since such a file must not have any holes.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
dd: Convert and copy a file
dd copies a file (from standard input to standard output, by
default) with a changeable I/O block size, while optionally performing
conversions on it. Synopsis:
dd [option]... |
The program accepts the following options. Also see 2. Common options.
The numeric-valued options below (bytes and blocks) can be followed by a multiplier: `b'=512, `c'=1, `w'=2, `xm'=m, or any of the standard block size suffixes like `k'=1024 (see section 2.2 Block size).
Use different dd invocations to use different block sizes for
skipping and I/O. For example, the following shell commands copy data
in 512 KiB blocks between a disk and a tape, but do not save or restore a
4 KiB label at the start of the disk:
disk=/dev/rdsk/c0t1d0s2 tape=/dev/rmt/0 # Copy all but the label from disk to tape. (dd bs=4k skip=1 count=0 && dd bs=512k) <$disk >$tape # Copy from tape back to disk, but leave the disk label alone. (dd bs=4k seek=1 count=0 && dd bs=512k) <$tape >$disk |
dd truncates file to zero
bytes (or the size specified with `seek=').
Conversions:
dd, unlike others, works
when an odd number of bytes are read--the last byte is simply copied
(since there is nothing to swap it with).
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
install: Copy files and set attributes
install copies files while setting their permission modes and, if
possible, their owner and group. Synopses:
install [option]... source dest install [option]... source... directory install -d [option]... directory... |
In the first of these, the source file is copied to the dest target file. In the second, each of the source files are copied to the destination directory. In the last, each directory (and any missing parent directories) is created.
install is similar to cp, but allows you to control the
attributes of destination files. It is typically used in Makefiles to
copy programs into their destination directories. It refuses to copy
files onto themselves.
The program accepts the following options. Also see 2. Common options.
install.
install, which
gives directories that it creates the default attributes.)
chmod, with 0 as the point of departure (see section 26. File permissions). The default mode is `u=rwx,go=rx'---read, write,
and execute for the owner, and read and execute for group and other.
install has appropriate privileges (is run as root), set the
ownership of installed files or directories to owner. The default
is root. owner may be either a user name or a numeric user
ID.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
mv: Move (rename) files
mv moves or renames files (or directories). Synopsis:
mv [option]... source dest mv [option]... source... directory |
If the last argument names an existing directory, mv moves each
other given file into a file with the same name in that directory.
Otherwise, if only two files are given, it renames the first as
the second. It is an error if the last argument is not a directory
and more than two files are given.
mv can move any type of file from one filesystem to another.
Prior to version 4.0 of the fileutils,
mv could move only regular files between filesystems.
For example, now mv can move an entire directory hierarchy
including special device files from one partition to another. It first
uses some of the same code that's used by cp -a to copy the
requested directories and files, then (assuming the copy succeeded)
it removes the originals. If the copy fails, then the part that was
copied to the destination partition is removed. If you were to copy
three directories from one partition to another and the copy of the first
directory succeeded, but the second didn't, the first would be left on
the destination partition and the second and third would be left on the
original partition.
If a destination file exists but is normally unwritable, standard input
is a terminal, and the `-f' or `--force' option is not given,
mv prompts the user for whether to replace the file. (You might
own the file, or have write permission on its directory.) If the
response does not begin with `y' or `Y', the file is skipped.
Warning: If you try to move a symlink that points to a directory,
and you specify the symlink with a trailing slash, then mv
doesn't move the symlink but instead moves the directory referenced
by the symlink. See section 2.4 Trailing slashes.
The program accepts the following options. Also see 2. Common options.
mv act as if `no' were
given as a response to every prompt about a destination file.
Specify `--reply=query' to make mv prompt the user
about each existing destination file.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
rm: Remove files or directories
rm removes each given file. By default, it does not remove
directories. Synopsis:
rm [option]... [file]... |
If a file is unwritable, standard input is a terminal, and the `-f'
or `--force' option is not given, or the `-i' or
`--interactive' option is given, rm prompts the user
for whether to remove the file. If the response does not begin with
`y' or `Y', the file is skipped.
Warning: If you use rm to remove a file, it is usually
possible to recover the contents of that file. If you want more assurance
that the contents are truly unrecoverable, consider using shred.
The program accepts the following options. Also see 2. Common options.
unlink function rather than
the rmdir function, and
don't require a directory to be empty before trying to unlink it. This works
only if you have appropriate privileges and if your operating system supports
unlink for directories. Because unlinking a directory causes any files
in the deleted directory to become unreferenced, it is wise to fsck
the filesystem after doing this.
One common question is how to remove files whose names begin with a
`-'. GNU rm, like every program that uses the getopt
function to parse its arguments, lets you use the `--' option to
indicate that all following arguments are non-options. To remove a file
called `-f' in the current directory, you could type either:
rm -- -f |
or:
rm ./-f |
The Unix rm program's use of a single `-' for this purpose
predates the development of the getopt standard syntax.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
shred: Remove files more securely
shred overwrites devices or files, to help prevent even
very expensive hardware from recovering the data.
Ordinarily when you remove a file (see section 11.5 rm: Remove files or directories), the data is
not actually destroyed. Only the index listing where the file is
stored is destroyed, and the storage is made available for reuse.
There are undelete utilities that will attempt to reconstruct the index
and can bring the file back if the parts were not reused.
On a busy system with a nearly-full drive, space can get reused in a few seconds. But there is no way to know for sure. If you have sensitive data, you may want to be sure that recovery is not possible by actually overwriting the file with non-sensitive data.
However, even after doing that, it is possible to take the disk back to a laboratory and use a lot of sensitive (and expensive) equipment to look for the faint "echoes" of the original data underneath the overwritten data. If the data has only been overwritten once, it's not even that hard.
The best way to remove something irretrievably is to destroy the media
it's on with acid, melt it down, or the like. For cheap removable media
like floppy disks, this is the preferred method. However, hard drives
are expensive and hard to melt, so the shred utility tries
to achieve a similar effect non-destructively.
This uses many overwrite passes, with the data patterns chosen to maximize the damage they do to the old data. While this will work on floppies, the patterns are designed for best effect on hard drives. For more details, see the source code and Peter Gutmann's paper Secure Deletion of Data from Magnetic and Solid-State Memory, from the proceedings of the Sixth USENIX Security Symposium (San Jose, California, 22--25 July, 1996). The paper is also available online http://www.cs.auckland.ac.nz/~pgut001/pubs/secure_del.html.
Please note that shred relies on a very important assumption:
that the filesystem overwrites data in place. This is the traditional
way to do things, but many modern filesystem designs do not satisfy this
assumption. Exceptions include:
If you are not sure how your filesystem operates, then you should assume that it does not overwrite data in place, which means that shred cannot reliably operate on regular files in your filesystem.
Generally speaking, it is more reliable to shred a device than a file,
since this bypasses the problem of filesystem design mentioned above.
However, even shredding devices is not always completely reliable. For
example, most disks map out bad sectors invisibly to the application; if
the bad sectors contain sensitive data, shred won't be able to
destroy it.
shred makes no attempt to detect or report this problem, just as
it makes no attempt to do anything about backups. However, since it is
more reliable to shred devices than files, shred by default does
not truncate or remove the output file. This default is more suitable
for devices, which typically cannot be truncated and should not be
removed.
Finally, consider the risk of backups and mirrors.
File system backups and remote mirrors may contain copies of the
file that cannot be removed, and that will allow a shredded file
to be recovered later. So if you keep any data you may later want
to destroy using shred, be sure that it is not backed up or mirrored.
shred [option]... file[...] |
The program accepts the following options. Also see 2. Common options.
shred uses 25 passes of overwrite. This is enough
for all of the useful overwrite patterns to be used at least once.
You can reduce this to save time, or increase it if you have a lot of
time to waste.
shred writes is made up of
random data. If this would be conspicuous on your hard drive (for
example, because it looks like encrypted data), or you just think
it's tidier, the `--zero' option adds an additional overwrite pass with
all zero bits. This is in addition to the number of passes specified
by the `--iterations' option.
This argument is considered an option. If the common `--' option has been used to indicate the end of options on the command line, then `-' will be interpreted as an ordinary file name.
The intended use of this is to shred a removed temporary file. For example
i=`tempfile -m 0600` exec 3<>"$i" rm -- "$i" echo "Hello, world" >&3 shred - >&3 exec 3>- |
Note that the shell command `shred - >file' does not shred the
contents of file, since it truncates file before invoking
shred. Use the command `shred file' or (if using a
Bourne-compatible shell) the command `shred - 1<>file' instead.
You might use the following command to erase all trace of the filesystem you'd created on the floppy disk in your first drive. That command takes about 20 minutes to erase a "1.44MB" (actually 1440 KiB) floppy.
shred --verbose /dev/fd0 |
Similarly, to erase all data on a selected partition of your hard disk, you could give a command like this:
shred --verbose /dev/sda5 |
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |