How can I copy a file on Unix using C

Question

I m looking for the Unix equivalent of Win32 s CopyFile  I don t want to reinvent the wheel by writing my own version

User · Answer

There is no baked-in equivalent CopyFile function in the APIs. But sendfile can be used to copy a file in kernel mode which is a faster and better solution (for numerous reasons) than opening a file, looping over it to read into a buffer, and writing the output to another file.

Update:

As of Linux kernel version 2.6.33, the limitation requiring the output of sendfile to be a socket was lifted and the original code would work on both Linux and — however, as of OS X 10.9 Mavericks, sendfile on OS X now requires the output to be a socket and the code won't work!

The following code snippet should work on the most OS X (as of 10.5), (Free)BSD, and Linux (as of 2.6.33). The implementation is "zero-copy" for all platforms, meaning all of it is done in kernelspace and there is no copying of buffers or data in and out of userspace. Pretty much the best performance you can get.

#include <fcntl.h>
#include <unistd.h>
#if defined(__APPLE__) || defined(__FreeBSD__)
#include <copyfile.h>
#else
#include <sys/sendfile.h>
#endif

int OSCopyFile(const char* source, const char* destination)
{    
    int input, output;    
    if ((input = open(source, O_RDONLY)) == -1)
    {
        return -1;
    }    
    if ((output = creat(destination, 0660)) == -1)
    {
        close(input);
        return -1;
    }

    //Here we use kernel-space copying for performance reasons
#if defined(__APPLE__) || defined(__FreeBSD__)
    //fcopyfile works on FreeBSD and OS X 10.5+ 
    int result = fcopyfile(input, output, 0, COPYFILE_ALL);
#else
    //sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+
    off_t bytesCopied = 0;
    struct stat fileinfo = {0};
    fstat(input, &fileinfo);
    int result = sendfile(output, input, &bytesCopied, fileinfo.st_size);
#endif

    close(input);
    close(output);

    return result;
}

EDIT: Replaced the opening of the destination with the call to creat() as we want the flag O_TRUNC to be specified. See comment below.

User · Answer

One option is that you could use system   to execute cp   This just re-uses the cp 1  command to do the work   If you only need to make another link to the file  this can be done with link   or symlink

User · Answer

There is no need to either call non-portable APIs like sendfile  or shell out to external utilities   The same method that worked back in the 70s still works now    include  lt fcntl h gt   include  lt unistd h gt   include  lt errno h gt   int cp const char  to  const char  from        int fd to  fd from      char buf 4096       ssize t nread      int saved errno       fd from   open from  O RDONLY       if  fd from  lt  0          return -1       fd to   open to  O WRONLY   O CREAT   O EXCL  0666       if  fd to  lt  0          goto out error       while  nread   read fd from  buf  sizeof buf   nread  gt  0                char  out ptr   buf          ssize t nwritten           do               nwritten   write fd to  out ptr  nread                if  nwritten  gt   0                                nread -  nwritten                  out ptr    nwritten                            else if  errno    EINTR                                goto out error                          while  nread  gt  0              if  nread    0                if  close fd to   lt  0                        fd to   -1              goto out error                    close fd from               Success             return 0           out error      saved errno   errno       close fd from       if  fd to  gt   0          close fd to        errno   saved errno      return -1

User · Answer

sprintf  cmd    bin cp -p    s      s     old  new    system  cmd     Add some error checks     Otherwise  open both and loop on read write  but probably not what you want        UPDATE to address valid security concerns   Rather than using  system     do a fork wait  and call execv   or execl   in the child   execl    bin cp    -p   old  new

User · Answer

Copying files byte-by-byte does work  but is slow and wasteful on modern UNIXes  Modern UNIXes have    copy-on-write    support built-in to the filesystem  a system call makes a new directory entry pointing at the existing bytes on disk  and no file content bytes on disk are touched until one of the copies is modified  at which point only the changed blocks are written to disk  This allows near-instant file copies that use no additional file blocks  regardless of file size  For example  here are some details about how this works in xfs  On linux  use the FICLONE ioctl as coreutils cp now does by default    ifdef FICLONE    return ioctl  dest fd  FICLONE  src fd     else    errno   ENOTSUP     return -1    endif  On macOS  use clonefile 2  for instant copies on APFS volumes  This is what Apple   s cp -c uses  The docs are not completely clear but it is likely that copyfile 3  with COPYFILE CLONE also uses this  Leave a comment if you   d like me to test that  In case these copy-on-write operations are not supported   whether the OS is too old  the underlying file system does not support it  or because you are copying files between different filesystems   you do need to fall back to trying sendfile  or as a last resort  copying byte-by-byte  But to save everyone a lot of time and disk space  please give FICLONE and clonefile 2  a try first

User · Answer

Another variant of the copy function using normal POSIX calls and without any loop  Code inspired from the buffer copy variant of the answer of caf  Warning  Using mmap can easily fail on 32 bit systems  on 64 bit system the danger is less likely    include  lt fcntl h gt   include  lt unistd h gt   include  lt errno h gt   include  lt sys mman h gt   int cp const char  to  const char  from      int fd from   open from  O RDONLY     if fd from  lt  0      return -1    struct stat Stat    if fstat fd from   amp Stat  lt 0      goto out error     void  mem   mmap NULL  Stat st size  PROT READ  MAP SHARED  fd from  0     if mem    MAP FAILED      goto out error     int fd to   creat to  0666     if fd to  lt  0      goto out error     ssize t nwritten   write fd to  mem  Stat st size     if nwritten  lt  Stat st size      goto out error     if close fd to   lt  0        fd to   -1      goto out error        close fd from         Success       return 0    out error     int saved errno   errno     close fd from     if fd to  gt   0      close fd to      errno   saved errno    return -1      EDIT  Corrected the file creation bug  See comment in http   stackoverflow com questions 2180079 how-can-i-copy-a-file-on-unix-using-c 2180157 2180157 answer

User · Answer

include  lt unistd h gt   include  lt string h gt   include  lt errno h gt   include  lt fcntl h gt   include  lt sys types h gt   include  lt sys stat h gt   include  lt stdio h gt    define    print err format  args       printf    s  d  error   format   n     func      LINE      args   define    DATA BUF SIZE                 64   1024       limit to read maximum 64 KB data per time  int32 t get file size const char  fname       struct stat sbuf       if  NULL    fname    strlen fname   lt  1           return 0             if  stat fname   amp sbuf   lt  0           print err   s   s   fname  strerror errno            return 0             return sbuf st size     off t shall be signed interge types  used for file size       bool copyFile CHAR  pszPathIn  CHAR  pszPathOut        INT32 fdIn  fdOut      UINT32 ulFileSize in   0      UINT32 ulFileSize out   0      CHAR  szDataBuf       if   pszPathIn     pszPathOut                print err   Invalid param             return false             if   1  gt  strlen pszPathIn       1  gt  strlen pszPathOut                  print err   Invalid param             return false             if  0    access pszPathIn  F OK                 print err    s   s    pszPathIn  strerror errno            return false             if  0  gt   fdIn   open pszPathIn  O RDONLY                  print err  open  s    failed   s   pszPathIn  strerror errno            return false             if  0  gt   fdOut   open pszPathOut  O CREAT   O WRONLY   O TRUNC  0777                  print err  open  s    failed   s   pszPathOut  strerror errno            close fdIn           return false             szDataBuf   malloc DATA BUF SIZE       if  NULL    szDataBuf                print err  malloc   failed             return false             while  1                INT32 slSizeRead   read fdIn  szDataBuf  sizeof szDataBuf            INT32 slSizeWrite          if  slSizeRead  lt   0                        break                     slSizeWrite   write fdOut  szDataBuf  slSizeRead           if  slSizeWrite  lt  0                        print err  write     slSizeRead  failed   s   slSizeRead  strerror errno                break                     if  slSizeWrite    slSizeRead     verify wheter write all byte data successfully                          print err   write      d  failed    slSizeRead               break                       close fdIn       fsync fdOut      causes all modified data and attributes to be moved to a permanent storage device        close fdOut        ulFileSize in   get file size pszPathIn       ulFileSize out   get file size pszPathOut       if  ulFileSize in    ulFileSize out     verify again wheter write all byte data successfully                  free szDataBuf           return true            free szDataBuf       return false

User · Answer

There is a way to do this  without resorting to the system call  you need to incorporate a wrapper something like this    include  lt sys sendfile h gt   include  lt fcntl h gt   include  lt unistd h gt          http   www unixguide net unix programming 2 5 shtml     About locking mechanism        int copy file const char  source  const char  dest      int fdSource   open source  O RDWR          Caf s comment about race condition          if  fdSource  gt  0        if  lockf fdSource  F LOCK  0     -1  return 0     FAILURE        else return 0     FAILURE           Now the fdSource is locked        int fdDest   open dest  O CREAT      off t lCount     struct stat sourceStat     if  fdSource  gt  0  amp  amp  fdDest  gt  0         if   stat source   amp sourceStat              int len   sendfile fdDest  fdSource   amp lCount  sourceStat st size             if  len  gt  0  amp  amp  len    sourceStat st size                  close fdDest                  close fdSource                      Sanity Check for Lock  if this is locked -1 is returned                    if  lockf fdSource  F TEST  0     0                      if  lockf fdSource  F ULOCK  0     -1                            WHOOPS  WTF  FAILURE TO UNLOCK                         else                        return 1     Success                                         else                        WHOOPS  WTF  TEST LOCK IS -1 WTF                        return 0     FAILURE                                                 return 0     Failure        The above sample  error checking is omitted   employs open  close and sendfile   Edit  As caf has pointed out a race condition can occur between the open and stat so I thought I d make this a bit more robust   Keep in mind that the locking mechanism varies from platform to platform   under Linux  this locking mechanism with lockf would suffice  If you want to make this portable  use the  ifdef macros to distinguish between different platforms compilers   Thanks caf for spotting this   There is a link to a site that yielded  universal locking routines  here

User · Answer

It s straight forward to use fork execl to run cp to do the work for you   This has advantages over system in that it is not prone to a Bobby Tables attack and you don t need to sanitize the arguments to the same degree   Further  since system   requires you to cobble together the command argument  you are not likely to have a buffer overflow issue due to sloppy sprintf   checking   The advantage to calling cp directly instead of writing it is not having to worry about elements of the target path existing in the destination   Doing that in roll-you-own code is error-prone and tedious   I wrote this example in ANSI C and only stubbed out the barest error handling  other than that it s straight forward code   void copy char  source  char  dest        int childExitStatus      pid t pid      int status      if   source     dest               handle as you wish               pid   fork         if  pid    0       child            execl   bin cp     bin cp   source  dest   char   0             else if  pid  lt  0               error - couldn t start process - you decide how to handle              else              parent - wait for child - this has all error handling  you            could just call wait   as long as you are only expecting to            have one child process at a time                      pid t ws   waitpid  pid   amp childExitStatus  WNOHANG           if  ws    -1               error - handle as you wish                       if  WIFEXITED childExitStatus      exit code in childExitStatus                          status   WEXITSTATUS childExitStatus      zero is normal exit                   handle non-zero as you wish                      else if  WIFSIGNALED childExitStatus      killed                                else if  WIFSTOPPED childExitStatus      stopped

[c] How can I copy a file on Unix using C?

Examples related to c

Examples related to unix

Examples related to copy