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  */
isSourceNewer(const struct stat * pSrcStat,const struct stat * pDstStat)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  */
isHiresMtime(const struct stat * pSrcStat)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  */
isSameFile(const struct stat * pSrcStat,const struct stat * pDstStat)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 
printCopyMsg(const char * src,const char * dst,unsigned int options)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 
printNotNewerMsg(const char * src,const char * dst,unsigned int options)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  */
copyFileContents(const char * dst,int dstFd,const char * src,int srcFd)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' (%zd of %zd)\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  */
setPermissions(const char * dst,const struct stat * pSrcStat,unsigned int options)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  */
copyRegular(const char * src,const char * dst,const struct stat * pSrcStat,unsigned int options)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  */
copySymlink(const char * src,const char * dst,const struct stat * pSrcStat,unsigned int options)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  */
copyDirectory(const char * src,const char * dst,const struct stat * pSrcStat,unsigned int options)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  */
copyFileRecursive(const char * src,const char * dst,bool isCmdLine,unsigned int options)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 
copyFile(const char * src,const char * dst,unsigned int options)640 int copyFile(const char* src, const char* dst, unsigned int options)
641 {
642     return copyFileRecursive(src, dst, true, options);
643 }
644 
645 
646