libs/host/CopyFile.c

   1 /*
   2  * Copyright 2005 The Android Open Source Project
   3  *
   4  * Android "cp" replacement.
   5  *
   6  * The GNU/Linux "cp" uses O_LARGEFILE in its open() calls, utimes() instead
   7  * of utime(), and getxattr()/setxattr() instead of chmod().  These are
   8  * probably "better", but are non-portable, and not necessary for our
   9  * purposes.
  10  */
  11 #include <host/CopyFile.h>
  12
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <getopt.h>
  20 #include <dirent.h>
  21 #include <fcntl.h>
  22 #include <utime.h>
  23 #include <limits.h>
  24 #include <errno.h>
  25 #include <assert.h>
  26
  27 #ifdef HAVE_MS_C_RUNTIME
  28 #  define  mkdir(path,mode)   _mkdir(path)
  29 #endif
  30
  31 #ifndef HAVE_SYMLINKS
  32 #  define  lstat              stat
  33 #  ifndef EACCESS   /* seems to be missing from the Mingw headers */
  34 #    define  EACCESS            13
  35 #  endif
  36 #endif
  37
  38 #ifndef O_BINARY
  39 #  define  O_BINARY  0
  40 #endif
  41
  42 /*#define DEBUG_MSGS*/
  43 #ifdef DEBUG_MSGS
  44 # define DBUG(x) printf x
  45 #else
  46 # define DBUG(x) ((void)0)
  47 #endif
  48
  49 #define FSSEP '/'       /* filename separator char */
  50
  51 static int copyFileRecursive(const char* src, const char* dst, bool isCmdLine, unsigned int options);
  52
  53 /*
  54  * Returns true if the source file is newer than the destination file.
  55  *
  56  * The check is based on the modification date, whole seconds only.  This
  57  * also returns true if the file sizes don't match.
  58  */
  59 static bool isSourceNewer(const struct stat* pSrcStat, const struct stat* pDstStat)
  60 {
  61     return (pSrcStat->st_mtime > pDstStat->st_mtime) ||
  62            (pSrcStat->st_size != pDstStat->st_size);
  63 }
  64
  65 /*
  66  * Returns true if the source file has high resolution modification
  67  * date. Cygwin/Mingw doesn't support st_mtim and always returns false.
  68  */
  69 static bool isHiresMtime(const struct stat* pSrcStat)
  70 {
  71 #if HAVE_STAT_ST_MTIM
  72 #if defined(MACOSX_RSRC)
  73     return pSrcStat->st_mtimespec.tv_nsec > 0;
  74 #else
  75     return pSrcStat->st_mtim.tv_nsec > 0;
  76 #endif
  77 #else
  78     return 0;
  79 #endif
  80 }
  81
  82 /*
  83  * Returns true if the source and destination files are actually the
  84  * same thing.  We detect this by checking the inode numbers, which seems
  85  * to work on Cygwin.
  86  */
  87 static bool isSameFile(const struct stat* pSrcStat, const struct stat* pDstStat)
  88 {
  89 #ifndef HAVE_VALID_STAT_ST_INO
  90     /* with MSVCRT.DLL, stat always sets st_ino to 0, and there is no simple way to */
  91         /* get the equivalent information with Win32 (Cygwin does some weird stuff in   */
  92         /* its winsup/cygwin/fhandler_disk_file.cc to emulate this, too complex for us) */
  93         return 0;
  94 #else
  95     return (pSrcStat->st_ino == pDstStat->st_ino);
  96 #endif
  97 }
  98
  99 static void printCopyMsg(const char* src, const char* dst, unsigned int options)
 100 {
 101     if ((options & COPY_VERBOSE_MASK) > 0)
 102         printf("    '%s' --> '%s'\n", src, dst);
 103 }
 104
 105 static void printNotNewerMsg(const char* src, const char* dst, unsigned int options)
 106 {
 107     if ((options & COPY_VERBOSE_MASK) > 1)
 108         printf("    '%s' is up-to-date\n", dst);
 109 }
 110
 111 /*
 112  * Copy the contents of one file to another.
 113  *
 114  * The files are assumed to be seeked to the start.
 115  */
 116 static int copyFileContents(const char* dst, int dstFd, const char* src, int srcFd)
 117 {
 118     unsigned char buf[8192];
 119     ssize_t readCount, writeCount;
 120
 121     /*
 122      * Read a chunk, write it, and repeat.
 123      */
 124     while (1) {
 125         readCount = read(srcFd, buf, sizeof(buf));
 126         if (readCount < 0) {
 127             fprintf(stderr,
 128                 "acp: failed reading '%s': %s\n", src, strerror(errno));
 129             return -1;
 130         }
 131
 132         if (readCount > 0) {
 133             writeCount = write(dstFd, buf, readCount);
 134             if (writeCount < 0) {
 135                 fprintf(stderr,
 136                     "acp: failed writing '%s': %s\n", dst, strerror(errno));
 137                 return -1;
 138             }
 139             if (writeCount != readCount) {
 140                 fprintf(stderr, "acp: partial write to '%s' (%d of %d)\n",
 141                     dst, writeCount, readCount);
 142                 return -1;
 143             }
 144         }
 145
 146         if (readCount < (ssize_t) sizeof(buf))
 147             break;
 148     }
 149
 150     return 0;
 151 }
 152
 153 /*
 154  * Set the permissions, owner, and timestamps on the destination file
 155  * equal to those of the source file.
 156  *
 157  * Failures here are "soft"; they don't produce warning messages and don't
 158  * cause the cp command to report a failure.
 159  */
 160 static int setPermissions(const char* dst, const struct stat* pSrcStat, unsigned int options)
 161 {
 162     struct utimbuf ut;
 163
 164     if (options & COPY_TIMESTAMPS) {
 165         /*
 166          * Start with timestamps.  The access and mod dates are not affected
 167          * by the next operations.
 168          */
 169         ut.actime = pSrcStat->st_atime;
 170         ut.modtime = pSrcStat->st_mtime;
 171         if (isHiresMtime(pSrcStat))
 172             ut.modtime += 1;
 173         if (utime(dst, &ut) != 0) {
 174             DBUG(("---   unable to set timestamps on '%s': %s\n",
 175                 dst, strerror(errno)));
 176         }
 177     }
 178
 179     if (options & COPY_PERMISSIONS) {
 180         /*
 181          * Set the permissions.
 182          */
 183         if (chmod(dst, pSrcStat->st_mode & ~(S_IFMT)) != 0) {
 184             DBUG(("---   unable to set perms on '%s' to 0%o: %s\n",
 185                 dst, pSrcStat->st_mode & ~(S_IFMT), strerror(errno)));
 186         }
 187 #ifndef HAVE_MS_C_RUNTIME
 188         /*
 189          * Set the owner.
 190          */
 191         if (chown(dst, pSrcStat->st_uid, pSrcStat->st_gid) != 0) {
 192             DBUG(("---   unable to set owner of '%s' to %d/%d: %s\n",
 193                 dst, pSrcStat->st_uid, pSrcStat->st_gid, strerror(errno)));
 194         }
 195 #endif
 196     }
 197
 198     return 0;
 199 }
 200
 201 /*
 202  * Copy a regular file.  If the destination file exists and is not a
 203  * regular file, we fail.  However, we use stat() rather than lstat(),
 204  * because it's okay to write through a symlink (the noDereference stuff
 205  * only applies to the source file).
 206  *
 207  * If the file doesn't exist, create it.  If it does exist, truncate it.
 208  */
 209 static int copyRegular(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
 210 {
 211     struct stat dstStat;
 212     int srcFd, dstFd, statResult, copyResult;
 213
 214     DBUG(("--- copying regular '%s' to '%s'\n", src, dst));
 215
 216     statResult = stat(dst, &dstStat);
 217     if (statResult == 0 && !S_ISREG(dstStat.st_mode)) {
 218         fprintf(stderr,
 219             "acp: destination '%s' exists and is not regular file\n",
 220             dst);
 221         return -1;
 222     } else if (statResult != 0 && errno != ENOENT) {
 223         fprintf(stderr, "acp: unable to stat destination '%s'\n", dst);
 224         return -1;
 225     }
 226
 227     if (statResult == 0) {
 228         if (isSameFile(pSrcStat, &dstStat)) {
 229             fprintf(stderr, "acp: '%s' and '%s' are the same file\n",
 230                 src, dst);
 231             return -1;
 232         }
 233         if (options & COPY_UPDATE_ONLY) {
 234             if (!isSourceNewer(pSrcStat, &dstStat)) {
 235                 DBUG(("---  source is not newer: '%s'\n", src));
 236                 printNotNewerMsg(src, dst, options);
 237                 return 0;
 238             }
 239         }
 240     }
 241
 242     /* open src */
 243     srcFd = open(src, O_RDONLY | O_BINARY, 0);
 244     if (srcFd < 0) {
 245         fprintf(stderr, "acp: unable to open '%s': %s\n", src, strerror(errno));
 246         return -1;
 247     }
 248
 249     /* open dest with O_CREAT | O_TRUNC */
 250     DBUG(("---  opening '%s'\n", dst));
 251     dstFd = open(dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
 252
 253     if (dstFd < 0) {
 254         if (errno == ENOENT) {
 255             /* this happens if the target directory doesn't exist */
 256             fprintf(stderr,
 257                 "acp: cannot create '%s': %s\n", dst, strerror(errno));
 258             (void) close(srcFd);
 259             return -1;
 260         }
 261
 262         /* if "force" is set, try removing the destination file and retry */
 263         if (options & COPY_FORCE) {
 264             if (unlink(dst) != 0) {
 265 #ifdef HAVE_MS_C_RUNTIME
 266                                 /* MSVCRT.DLL unlink will fail with EACCESS if the file is set read-only */
 267                                 /* so try to change its mode, and unlink again                           */
 268                                 if (errno == EACCESS) {
 269                                         if (chmod(dst, S_IWRITE|S_IREAD) == 0 && unlink(dst) == 0)
 270                                                 goto Open_File;
 271                                 }
 272 #endif
 273                 fprintf(stderr, "acp: unable to remove '%s': %s\n",
 274                     dst, strerror(errno));
 275                 (void) close(srcFd);
 276                 return -1;
 277             }
 278 #ifdef HAVE_MS_C_RUNTIME
 279         Open_File:
 280 #endif
 281             dstFd = open(dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
 282         }
 283     }
 284     if (dstFd < 0) {
 285         fprintf(stderr, "acp: unable to open '%s': %s\n",
 286             dst, strerror(errno));
 287         (void) close(srcFd);
 288         return -1;
 289     }
 290
 291     copyResult = copyFileContents(dst, dstFd, src, srcFd);
 292
 293     (void) close(srcFd);
 294     (void) close(dstFd);
 295     if (copyResult != 0)
 296         return -1;
 297
 298 #ifdef MACOSX_RSRC
 299     {
 300         char* srcRsrcName = NULL;
 301         char* dstRsrcName = NULL;
 302         struct stat rsrcStat;
 303
 304         srcRsrcName = malloc(strlen(src) + 5 + 1);
 305         strcpy(srcRsrcName, src);
 306         strcat(srcRsrcName, "/rsrc");
 307
 308         dstRsrcName = malloc(strlen(dst) + 5 + 1);
 309         strcpy(dstRsrcName, dst);
 310         strcat(dstRsrcName, "/rsrc");
 311
 312         if (stat(srcRsrcName, &rsrcStat) == 0 && rsrcStat.st_size > 0) {
 313             DBUG(("---  RSRC: %s --> %s\n", srcRsrcName, dstRsrcName));
 314
 315             srcFd = open(srcRsrcName, O_RDONLY);
 316             dstFd = open(dstRsrcName, O_TRUNC | O_WRONLY, 0);
 317             copyResult = -1;
 318             if (srcFd >= 0 && dstFd >= 0) {
 319                 copyResult = copyFileContents(dstRsrcName, dstFd,
 320                     srcRsrcName, srcFd);
 321                 (void) close(srcFd);
 322                 (void) close(dstFd);
 323             }
 324
 325             if (copyResult != 0)
 326                 return -1;
 327         }
 328
 329         free(srcRsrcName);
 330         free(dstRsrcName);
 331     }
 332 #endif
 333
 334     setPermissions(dst, pSrcStat, options);
 335
 336     printCopyMsg(src, dst, options);
 337
 338     return 0;
 339 }
 340
 341
 342 #ifdef HAVE_SYMLINKS
 343 /*
 344  * Copy a symlink.  This only happens if we're in "no derefence" mode,
 345  * in which we copy the links rather than the files that are pointed at.
 346  *
 347  * We always discard the destination file.  If it's a symlink already,
 348  * we want to throw it out and replace it.  If it's not a symlink, we
 349  * need to trash it so we can create one.
 350  */
 351 static int copySymlink(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
 352 {
 353     struct stat dstStat;
 354     char linkBuf[PATH_MAX+1];
 355     int statResult, nameLen;
 356
 357     assert(options & COPY_NO_DEREFERENCE);
 358     DBUG(("--- copying symlink '%s' to '%s'\n", src, dst));
 359
 360     /* NOTE: we use lstat() here */
 361     statResult = lstat(dst, &dstStat);
 362     if (statResult == 0 && !S_ISREG(dstStat.st_mode)
 363                          && !S_ISLNK(dstStat.st_mode)
 364                                                  )
 365     {
 366         fprintf(stderr,
 367             "acp: destination '%s' exists and is not regular or symlink\n",
 368             dst);
 369         return -1;
 370     }
 371
 372     if (statResult == 0) {
 373         if (isSameFile(pSrcStat, &dstStat)) {
 374             fprintf(stderr, "acp: '%s' and '%s' are the same file\n",
 375                 src, dst);
 376             return -1;
 377         }
 378         if (options & COPY_UPDATE_ONLY) {
 379             if (!isSourceNewer(pSrcStat, &dstStat)) {
 380                 DBUG(("---  source is not newer: '%s'\n", src));
 381                 printNotNewerMsg(src, dst, options);
 382                 return 0;
 383             }
 384         }
 385     }
 386
 387     /* extract the symlink contents */
 388     nameLen = readlink(src, linkBuf, sizeof(linkBuf)-1);
 389     if (nameLen <= 0) {
 390         fprintf(stderr, "acp: unable to read symlink '%s': %s\n",
 391             src, strerror(errno));
 392         return -1;
 393     }
 394     linkBuf[nameLen] = '\0';
 395     DBUG(("--- creating symlink file '%s' (--> %s)\n", dst, linkBuf));
 396
 397     if (statResult == 0) {
 398         DBUG(("---  removing '%s'\n", dst));
 399         if (unlink(dst) != 0) {
 400             fprintf(stderr, "acp: unable to remove '%s': %s\n",
 401                 dst, strerror(errno));
 402             return -1;
 403         }
 404     }
 405
 406     if (symlink(linkBuf, dst) != 0) {
 407         fprintf(stderr, "acp: unable to create symlink '%s' [%s]: %s\n",
 408             dst, linkBuf, strerror(errno));
 409         return -1;
 410     }
 411
 412     /*
 413      * There's no way to set the file date or access permissions, but
 414      * it is possible to set the owner.
 415      */
 416     if (options & COPY_PERMISSIONS) {
 417         if (lchown(dst, pSrcStat->st_uid, pSrcStat->st_gid) != 0)
 418             DBUG(("---  lchown failed: %s\n", strerror(errno)));
 419     }
 420
 421     printCopyMsg(src, dst, options);
 422
 423     return 0;
 424 }
 425 #endif /* HAVE_SYMLINKS */
 426
 427 /*
 428  * Copy the contents of one directory to another.  Both "src" and "dst"
 429  * must be directories.  We will create "dst" if it does not exist.
 430  */
 431 int copyDirectory(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
 432 {
 433     int retVal = 0;
 434     struct stat dstStat;
 435     DIR* dir;
 436     int cc, statResult;
 437
 438     DBUG(("--- copy dir '%s' to '%s'\n", src, dst));
 439
 440     statResult = stat(dst, &dstStat);
 441     if (statResult == 0 && !S_ISDIR(dstStat.st_mode)) {
 442         fprintf(stderr,
 443             "acp: destination '%s' exists and is not a directory\n", dst);
 444         return -1;
 445     } else if (statResult != 0 && errno != ENOENT) {
 446         fprintf(stderr, "acp: unable to stat destination '%s'\n", dst);
 447         return -1;
 448     }
 449
 450     if (statResult == 0) {
 451         if (isSameFile(pSrcStat, &dstStat)) {
 452             fprintf(stderr,
 453                 "acp: cannot copy directory into itself ('%s' and '%s')\n",
 454                 src, dst);
 455             return -1;
 456         }
 457     } else {
 458         DBUG(("---  creating dir '%s'\n", dst));
 459         cc = mkdir(dst, 0755);
 460         if (cc != 0) {
 461             fprintf(stderr, "acp: unable to create directory '%s': %s\n",
 462                 dst, strerror(errno));
 463             return -1;
 464         }
 465
 466         /* only print on mkdir */
 467         printCopyMsg(src, dst, options);
 468     }
 469
 470     /*
 471      * Open the directory, and plow through its contents.
 472      */
 473     dir = opendir(src);
 474     if (dir == NULL) {
 475         fprintf(stderr, "acp: unable to open directory '%s': %s\n",
 476             src, strerror(errno));
 477         return -1;
 478     }
 479
 480     while (1) {
 481         struct dirent* ent;
 482         char* srcFile;
 483         char* dstFile;
 484         int srcLen, dstLen, nameLen;
 485
 486         ent = readdir(dir);
 487         if (ent == NULL)
 488             break;
 489
 490         if (strcmp(ent->d_name, ".") == 0 ||
 491             strcmp(ent->d_name, "..") == 0)
 492         {
 493             continue;
 494         }
 495
 496         nameLen = strlen(ent->d_name);
 497         srcLen = strlen(src);
 498         dstLen = strlen(dst);
 499
 500         srcFile = malloc(srcLen +1 + nameLen +1);
 501         memcpy(srcFile, src, srcLen);
 502         srcFile[srcLen] = FSSEP;
 503         memcpy(srcFile + srcLen+1, ent->d_name, nameLen +1);
 504
 505         dstFile = malloc(dstLen +1 + nameLen +1);
 506         memcpy(dstFile, dst, dstLen);
 507         dstFile[dstLen] = FSSEP;
 508         memcpy(dstFile + dstLen+1, ent->d_name, nameLen +1);
 509
 510         if (copyFileRecursive(srcFile, dstFile, false, options) != 0)
 511             retVal = -1;        /* note failure and keep going */
 512
 513         free(srcFile);
 514         free(dstFile);
 515     }
 516     closedir(dir);
 517
 518     setPermissions(dst, pSrcStat, options);
 519
 520     return retVal;
 521 }
 522
 523 /*
 524  * Do the actual copy.  This is called recursively from copyDirectory().
 525  *
 526  * "dst" should only be a directory if "src" is also a directory.
 527  *
 528  * Returns 0 on success.
 529  */
 530 static int copyFileRecursive(const char* src, const char* dst, bool isCmdLine, unsigned int options)
 531 {
 532     char* srcExe = NULL;
 533     char* dstExe = NULL;
 534     char* dstDir = NULL;
 535     struct stat srcStat;
 536     int retVal = 0;
 537     int statResult, statErrno;
 538
 539     /*
 540      * Stat the source file.  If it doesn't exist, fail.
 541      */
 542     if (options & COPY_NO_DEREFERENCE)
 543         statResult = lstat(src, &srcStat);
 544     else
 545         statResult = stat(src, &srcStat);
 546     statErrno = errno;        /* preserve across .exe attempt */
 547
 548 #ifdef WIN32_EXE
 549     /*
 550      * Here's the interesting part.  Under Cygwin, if you have a file
 551      * called "foo.exe", stat("foo", ...) will succeed, but open("foo", ...)
 552      * will fail.  We need to figure out what its name is supposed to be
 553      * so we can create the correct destination file.
 554      *
 555      * If we don't have the "-e" flag set, we want "acp foo bar" to fail,
 556      * not automatically find "foo.exe".  That way, if we really were
 557      * trying to copy "foo", it doesn't grab something we don't want.
 558      */
 559     if (isCmdLine && statResult == 0) {
 560         int tmpFd;
 561         tmpFd = open(src, O_RDONLY | O_BINARY, 0);
 562         if (tmpFd < 0) {
 563             statResult = -1;
 564             statErrno = ENOENT;
 565         } else {
 566             (void) close(tmpFd);
 567         }
 568     }
 569
 570     /*
 571      * If we didn't find the file, try it again with ".exe".
 572      */
 573     if (isCmdLine && statResult < 0 && statErrno == ENOENT && (options & COPY_TRY_EXE)) {
 574         srcExe = malloc(strlen(src) + 4 +1);
 575         strcpy(srcExe, src);
 576         strcat(srcExe, ".exe");
 577
 578         if (options & COPY_NO_DEREFERENCE)
 579             statResult = lstat(srcExe, &srcStat);
 580         else
 581             statResult = stat(srcExe, &srcStat);
 582
 583         if (statResult == 0 && !S_ISREG(srcStat.st_mode))
 584             statResult = -1;        /* fail, use original statErrno below */
 585
 586         if (statResult == 0) {
 587             /* found a .exe, copy that instead */
 588             dstExe = malloc(strlen(dst) + 4 +1);
 589             strcpy(dstExe, dst);
 590             strcat(dstExe, ".exe");
 591
 592             src = srcExe;
 593             dst = dstExe;
 594         } else {
 595             DBUG(("---  couldn't find '%s' either\n", srcExe));
 596         }
 597     }
 598 #endif
 599     if (statResult < 0) {
 600         if (statErrno == ENOENT)
 601             fprintf(stderr, "acp: file '%s' does not exist\n", src);
 602         else
 603             fprintf(stderr, "acp: unable to stat '%s': %s\n",
 604                 src, strerror(statErrno));
 605         retVal = -1;
 606         goto bail;
 607     }
 608
 609     /*
 610      * If "src" is a directory, ignore it if "recursive" isn't set.
 611      *
 612      * We want to create "dst" as a directory (or verify that it already
 613      * exists as a directory), and then copy its contents.
 614      */
 615     if (S_ISDIR(srcStat.st_mode)) {
 616         if (!(options & COPY_RECURSIVE)) {
 617             fprintf(stderr, "acp: omitting directory '%s'\n", src);
 618         } else {
 619             retVal = copyDirectory(src, dst, &srcStat, options);
 620         }
 621 #ifdef HAVE_SYMLINKS
 622     } else if (S_ISLNK(srcStat.st_mode)) {
 623         retVal = copySymlink(src, dst, &srcStat, options);
 624 #endif
 625     } else if (S_ISREG(srcStat.st_mode)) {
 626         retVal = copyRegular(src, dst, &srcStat, options);
 627     } else {
 628         fprintf(stderr, "acp: skipping unusual file '%s' (mode=0%o)\n",
 629             src, srcStat.st_mode);
 630         retVal = -1;
 631     }
 632
 633 bail:
 634     free(srcExe);
 635     free(dstExe);
 636     free(dstDir);
 637     return retVal;
 638 }
 639
 640 int copyFile(const char* src, const char* dst, unsigned int options)
 641 {
 642     return copyFileRecursive(src, dst, true, options);
 643 }
 644
 645