Linux: HowTo Copy a Folder [ Command Line Option ]

Posted on in Categories last updated April 10, 2012

I‘m a new Linux user. How do I copy a directory or folder under Linux operating system using command line options and bash shell?

You can use various command to copy a folder under Linux operating systems.

cp Command

cp is a Linux command for copying files and directories. The syntax is as follows:

cp source destination
cp dir1 dir2
cp -option  source destination
cp -option1 -option2  source destination

In this example copy /home/vivek/letters folder and all its files to /usb/backup directory:

cp -avr /home/vivek/letters /usb/backup

Where,

  • -a : Preserve the specified attributes such as directory an file mode, ownership, timestamps, if possible additional attributes: context, links, xattr, all.
  • -v : Explain what is being done.
  • -r : Copy directories recursively.

Example

Copy a folder called /tmp/conf to /tmp/backup:
$ cp -avr /tmp/conf/ /tmp/backup
Sample outputs:

HowTO: Copy Folder Linux Terminal Command
Fig.01: cp command in action

rsync Command

You can also use rsync command which is a fast and extraordinarily versatile file copying tool. It can make copies across the network. The syntax is as follows:

rsync -av /path/to/source /path/to/destination
rsync -av /path/to/source/ /path/to/destination/source

To backup my home directory, which consists of large files and mail folders to /media/backup, enter:
$ rsync -avz /home/vivek /media/backup
I can copy a folder to remote machine called server1.cyberciti.biz:
$ rsync -avz /home/vivek/ server1.cyberciti.biz:/home/backups/vivek
Where,

  • -a : Archive mode i.e. copy a folder with all its permission and other information including recursive copy.
  • -v : Verbose mode.
  • -z : With this option, rsync compresses the file data as it is sent to the destination machine, which reduces the amount of data being transmitted — something that is useful over a slow connection.

You can show progress during transfer using –progress or -P option:
$ rsync -av --progress /path/to/source/ /path/to/dest
Sample outputs:

Copy Folder Linux Commands [ rsync ]
Fig.02: rsync command in action

Posted by: Vivek Gite

The author is the creator of nixCraft and a seasoned sysadmin and a trainer for the Linux operating system/Unix shell scripting. He has worked with global clients and in various industries, including IT, education, defense and space research, and the nonprofit sector. Follow him on Twitter, Facebook, Google+.

20 comment

    1. I know it’s like 3 years later but I figured I’d answer anyway.
      Since rsync is layers above the filesystem, it doesn’t matter. The nice part is the ability to ctrl-c out and restart with partial transfers. It’s a nice simple way to synchronize without needing to overthink things.

      1. Are you sure do not have an alias in place for cp? cp -r (recursive) allows for copying of folders recursively. Otherwise you will get an error trying to copy a folder without -r as an argument, UNLESS -r is set via an alias.

        You can confirm like this is a bash shell

        type without quotes ‘alias’

        ± |master ✗| → alias
        alias dir=’dir –color’
        alias l.=’ls -d .*’
        alias ll=’ls -l’
        alias ls=’ls –color’
        alias reload=’source ~/.bash_profile’
        alias vi=’vim’
        alias which=’alias | /usr/bin/which –tty-only –read-alias –show-dot –show-tilde’

  1. #
    # dircp.sh	A script to copy directory structures
    # May also be accomplished with: cp -av source-dir/ /dest-dir
    # LGD Thu Jul  2 11:33:09 PDT 2015
    #
    
    # Debug
    # set -x
    # set -v
    # exec $0 2>&1|tee $0.debug	# Puts error messages into wireless.sh.debug file
    
    PROMPT_CONTINUE="\n\t\t\tPlease press any key to continue ...\c"	# Prompt to end WAIT function
    
    WAIT(){							# Wait for keyboard input
      STTY_PARAM='stty -g'					# Save the terminal parameters
      stty -icanon eof '^a' min 1				# Configure the terminal interface to receive a single input character
      CHOICE=`dd bs=1 count=1 2>/dev/null`			# Wait for keyboard input
      echo $STTY_PARAM | stty 2>/dev/null			# Reset the terminal parameters
    }
    
    USAGE(){
    case "${1}" in
        "not_enough") ERR="Not enough arguments"		;;
        "too_many") ERR="Too many arguments"		;;
          "tree_err") ERR="Destination-Directory may not be below the Source-Directory in the same directory tree"	;;
          "arg1_d") ERR="Argument 1 is not a directory"	;;
          "arg2_d") ERR="Argument 2 is not a directory"	;;
                 *) MAIN					;;
    esac
    echo -e "\n`basename $0`: ${ERR}\nUSAGE: `basename $0`  \n"
    exit 1
    }
    
    DOIT(){
    echo -e "\nAre you sure?  You will be overwriting any files of the same name in $2. (y/N): \c"
    WAIT
    echo							# Provide newline for PROMPT_CONTINUE
    case $CHOICE in
    #    [yY]*) rsync -nav $1 $2; exit $? 			;; # Remove the -n argument to rsync to actually copy the directory tree
        [yY]*) rsync -va $1 $2; exit $? 			;; # Copy the directory tree
            *) echo -e "`basename $0`: Aborting"; exit 1	;;
    esac
    }
    
    MAIN(){
    # Usage Trap
    [ ${#} -lt 2 ] && USAGE not_enough			# Trap for wrong number of arguments
    [ ${#} -gt 2 ] && USAGE too_many			# Trap for wrong number of arguments
    #[ ${1} = '.' ] && USAGE tree_err			# Trap for non-directory argument 1
    cd "$1"; TREE_ERR=`find . -type d -path "$2"`; cd -	# Trap for destination-directory below source-directory (BUG: same dirname!)
    [ "${TREE_ERR}" = "${2}" ] && USAGE tree_err		#
    [ -d ${1} ] || USAGE arg1_d				# Trap for non-directory argument 1
    [ -d ${2} ] || USAGE arg2_d				# Trap for non-directory argument 2
    # Copy the directory
    DOIT "$1" "$2"
    }
    
    MAIN "$1" "$2"
    
  2. -r is a flag for recursive copying, meaning directories/files from subdirectories as well. cp will copy from the current directory without -r. Honest, it’s not a conspiracy.

Leave a Comment