4 * CPDUP <options> source destination
6 * (c) Copyright 1997-1999 by Matthew Dillon and Dima Ruban. Permission to
7 * use and distribute based on the FreeBSD copyright. Supplied as-is,
8 * USE WITH EXTREME CAUTION.
10 * This program attempts to duplicate the source onto the destination as
11 * exactly as possible, retaining modify times, flags, perms, uid, and gid.
12 * It can duplicate devices, files (including hardlinks), softlinks,
13 * directories, and so forth. It is recursive by default! The duplication
14 * is inclusive of removal of files/directories on the destination that do
15 * not exist on the source. This program supports a per-directory exception
16 * file called .cpignore, or a user-specified exception file.
20 * - does not cross partition boundries on source
21 * - asks for confirmation on deletions unless -i0 is specified
22 * - refuses to replace a destination directory with a source file
23 * unless -s0 is specified.
24 * - terminates on error
28 * - does not copy file if mtime, flags, perms, and size match unless
31 * - copies to temporary and renames-over the original, allowing
32 * you to update live systems
34 * - copies uid, gid, mtime, perms, flags, softlinks, devices, hardlinks,
35 * and recurses through directories.
37 * - accesses a per-directory exclusion file, .cpignore, containing
38 * standard wildcarded ( ? / * style, NOT regex) exclusions.
40 * - tries to play permissions and flags smart in regards to overwriting
41 * schg files and doing related stuff.
43 * - Can do MD5 consistancy checks
45 * - Is able to do incremental mirroring/backups via hardlinks from
46 * the 'previous' version (supplied with -H path).
48 * $DragonFly: src/bin/cpdup/cpdup.c,v 1.28 2008/05/23 06:55:11 dillon Exp $
52 * Example: cc -O cpdup.c -o cpdup -lmd
54 * ".MD5.CHECKSUMS" contains md5 checksumms for the current directory.
55 * This file is stored on the source.
63 #define HMASK (HSIZE-1)
65 #define HLMASK (HLSIZE - 1)
67 #define MAXDEPTH 32 /* max copy depth for thread */
68 #define GETBUFSIZE 8192
69 #define GETPATHSIZE 2048
70 #define GETLINKSIZE 1024
71 #define GETIOSIZE 65536
73 #ifndef _ST_FLAGS_PRESENT_
74 #define st_flags st_mode
79 struct Node
*no_HNext
;
99 typedef struct copy_info
{
105 struct copy_info
*parent
;
112 struct hlink
*hltable
[HLSIZE
];
114 void RemoveRecur(const char *dpath
, dev_t devNo
);
115 void InitList(List
*list
);
116 void ResetList(List
*list
);
117 int AddList(List
*list
, const char *name
, int n
);
118 static struct hlink
*hltlookup(struct stat
*);
119 static struct hlink
*hltadd(struct stat
*, const char *);
120 static char *checkHLPath(struct stat
*st
, const char *spath
, const char *dpath
);
121 static int validate_check(const char *spath
, const char *dpath
);
122 static int shash(const char *s
);
123 static void hltdelete(struct hlink
*);
124 static void hltsetdino(struct hlink
*, ino_t
);
125 int YesNo(const char *path
);
126 static int xrename(const char *src
, const char *dst
, u_long flags
);
127 static int xlink(const char *src
, const char *dst
, u_long flags
);
128 int WildCmp(const char *s1
, const char *s2
);
129 static int DoCopy(copy_info_t info
, int depth
);
131 int AskConfirmation
= 1;
143 int EnableDirectoryRetries
;
147 int MaxParallel
= -1;
149 const char *UseCpFile
;
150 const char *UseHLPath
;
151 const char *MD5CacheFile
;
152 const char *FSMIDCacheFile
;
154 int64_t CountSourceBytes
;
155 int64_t CountSourceItems
;
156 int64_t CountCopiedItems
;
157 int64_t CountSourceReadBytes
;
158 int64_t CountTargetReadBytes
;
159 int64_t CountWriteBytes
;
160 int64_t CountRemovedItems
;
161 int64_t CountLinkedItems
;
163 struct HostConf SrcHost
;
164 struct HostConf DstHost
;
167 pthread_mutex_t MasterMutex
;
171 main(int ac
, char **av
)
177 struct timeval start
;
178 struct copy_info info
;
180 signal(SIGPIPE
, SIG_IGN
);
183 pthread_mutex_init(&SrcHost
.read_mutex
, NULL
);
184 pthread_mutex_init(&DstHost
.read_mutex
, NULL
);
185 pthread_mutex_init(&MasterMutex
, NULL
);
186 pthread_mutex_lock(&MasterMutex
);
189 gettimeofday(&start
, NULL
);
190 for (i
= 1; i
< ac
; ++i
) {
197 } else if (dst
== NULL
) {
200 fatal("too many arguments");
208 v
= strtol(ptr
, NULL
, 0);
216 while (*ptr
== 'v') {
220 if (*ptr
>= '0' && *ptr
<= '9')
221 VerboseOpt
= strtol(ptr
, NULL
, 0);
237 UseCpFile
= ".cpignore";
240 UseCpFile
= (*ptr
) ? ptr
: av
[++i
];
243 UseHLPath
= (*ptr
) ? ptr
: av
[++i
];
268 FSMIDCacheFile
= ".FSMID.CHECK";
272 FSMIDCacheFile
= av
[++i
];
276 MD5CacheFile
= av
[++i
];
280 MD5CacheFile
= ".MD5.CHECKSUMS";
283 setvbuf(stdout
, NULL
, _IOLBF
, 0);
286 fatal("illegal option: %s\n", ptr
- 2);
293 * If we are told to go into slave mode, run the HC protocol
301 * Extract the source and/or/neither target [user@]host and
302 * make any required connections.
304 if (src
&& (ptr
= strchr(src
, ':')) != NULL
) {
305 asprintf(&SrcHost
.host
, "%*.*s", ptr
- src
, ptr
- src
, src
);
308 fprintf(stderr
, "The cpignore options are not currently supported for remote sources\n");
312 fprintf(stderr
, "The MD5 options are not currently supported for remote sources\n");
315 if (hc_connect(&SrcHost
) < 0)
318 if (dst
&& (ptr
= strchr(dst
, ':')) != NULL
) {
319 asprintf(&DstHost
.host
, "%*.*s", ptr
- dst
, ptr
- dst
, dst
);
322 fprintf(stderr
, "The FSMID options are not currently supported for remote targets\n");
325 if (hc_connect(&DstHost
) < 0)
330 * dst may be NULL only if -m option is specified,
331 * which forces an update of the MD5 checksums
333 if (dst
== NULL
&& UseMD5Opt
== 0) {
337 bzero(&info
, sizeof(info
));
341 pthread_cond_init(&info
.cond
, NULL
);
344 DstBaseLen
= strlen(dst
);
347 info
.sdevNo
= (dev_t
)-1;
348 info
.ddevNo
= (dev_t
)-1;
349 i
= DoCopy(&info
, -1);
353 info
.sdevNo
= (dev_t
)-1;
354 info
.ddevNo
= (dev_t
)-1;
355 i
= DoCopy(&info
, -1);
358 pthread_cond_destroy(&info
.cond
);
365 if (SummaryOpt
&& i
== 0) {
369 gettimeofday(&end
, NULL
);
371 /* don't count stat's in our byte statistics */
372 CountSourceBytes
+= sizeof(struct stat
) * CountSourceItems
;
373 CountSourceReadBytes
+= sizeof(struct stat
) * CountSourceItems
;
374 CountWriteBytes
+= sizeof(struct stat
) * CountCopiedItems
;
375 CountWriteBytes
+= sizeof(struct stat
) * CountRemovedItems
;
378 duration
= (end
.tv_sec
- start
.tv_sec
);
379 duration
+= (double)(end
.tv_usec
- start
.tv_usec
) / 1000000.0;
382 logstd("cpdup completed successfully\n");
383 logstd("%lld bytes source, %lld src bytes read, %lld tgt bytes read\n"
384 "%lld bytes written (%.1fX speedup)\n",
385 (long long)CountSourceBytes
,
386 (long long)CountSourceReadBytes
,
387 (long long)CountTargetReadBytes
,
388 (long long)CountWriteBytes
,
389 ((double)CountSourceBytes
* 2.0) / ((double)(CountSourceReadBytes
+ CountTargetReadBytes
+ CountWriteBytes
)));
390 logstd("%lld source items, %lld items copied, %lld items linked, "
391 "%lld things deleted\n",
392 (long long)CountSourceItems
,
393 (long long)CountCopiedItems
,
394 (long long)CountLinkedItems
,
395 (long long)CountRemovedItems
);
396 logstd("%.1f seconds %5d Kbytes/sec synced %5d Kbytes/sec scanned\n",
398 (int)((CountSourceReadBytes
+ CountTargetReadBytes
+ CountWriteBytes
) / duration
/ 1024.0),
399 (int)(CountSourceBytes
/ duration
/ 1024.0));
401 exit((i
== 0) ? 0 : 1);
404 static struct hlink
*
405 hltlookup(struct stat
*stp
)
408 struct timespec ts
= { 0, 100000 };
413 n
= stp
->st_ino
& HLMASK
;
418 for (hl
= hltable
[n
]; hl
; hl
= hl
->next
) {
419 if (hl
->ino
== stp
->st_ino
) {
422 * If the hl entry is still in the process of being created
423 * by another thread we have to wait until it has either been
424 * deleted or completed.
427 pthread_mutex_unlock(&MasterMutex
);
428 nanosleep(&ts
, NULL
);
429 pthread_mutex_lock(&MasterMutex
);
441 static struct hlink
*
442 hltadd(struct stat
*stp
, const char *path
)
445 int plen
= strlen(path
);
448 new = malloc(offsetof(struct hlink
, name
[plen
+ 1]));
450 fprintf(stderr
, "out of memory\n");
455 /* initialize and link the new element into the table */
456 new->ino
= stp
->st_ino
;
457 new->dino
= (ino_t
)-1;
459 bcopy(path
, new->name
, plen
+ 1);
462 n
= stp
->st_ino
& HLMASK
;
463 new->next
= hltable
[n
];
465 hltable
[n
]->prev
= new;
472 hltsetdino(struct hlink
*hl
, ino_t inum
)
478 hltdelete(struct hlink
*hl
)
480 assert(hl
->refs
== 1);
484 hl
->next
->prev
= hl
->prev
;
485 hl
->prev
->next
= hl
->next
;
488 hl
->next
->prev
= NULL
;
490 hltable
[hl
->ino
& HLMASK
] = hl
->next
;
497 hltrels(struct hlink
*hl
)
499 assert(hl
->refs
== 1);
504 * If UseHLPath is defined check to see if the file in question is
505 * the same as the source file, and if it is return a pointer to the
506 * -H path based file for hardlinking. Else return NULL.
509 checkHLPath(struct stat
*st1
, const char *spath
, const char *dpath
)
515 asprintf(&hpath
, "%s%s", UseHLPath
, dpath
+ DstBaseLen
);
518 * stat info matches ?
520 if (hc_stat(&DstHost
, hpath
, &sthl
) < 0 ||
521 st1
->st_size
!= sthl
.st_size
||
522 st1
->st_uid
!= sthl
.st_uid
||
523 st1
->st_gid
!= sthl
.st_gid
||
524 st1
->st_mtime
!= sthl
.st_mtime
531 * If ForceOpt or ValidateOpt is set we have to compare the files
533 if (ForceOpt
|| ValidateOpt
) {
534 error
= validate_check(spath
, hpath
);
544 * Return 0 if the contents of the file <spath> matches the contents of
548 validate_check(const char *spath
, const char *dpath
)
554 fd1
= hc_open(&SrcHost
, spath
, O_RDONLY
, 0);
555 fd2
= hc_open(&DstHost
, dpath
, O_RDONLY
, 0);
558 if (fd1
>= 0 && fd2
>= 0) {
561 char *iobuf1
= malloc(GETIOSIZE
);
562 char *iobuf2
= malloc(GETIOSIZE
);
564 while ((n
= hc_read(&SrcHost
, fd1
, iobuf1
, GETIOSIZE
)) > 0) {
565 CountSourceReadBytes
+= n
;
566 x
= hc_read(&DstHost
, fd2
, iobuf2
, GETIOSIZE
);
568 CountTargetReadBytes
+= x
;
571 if (bcmp(iobuf1
, iobuf2
, n
) != 0)
580 hc_close(&SrcHost
, fd1
);
582 hc_close(&DstHost
, fd2
);
588 DoCopyThread(void *arg
)
590 copy_info_t cinfo
= arg
;
591 char *spath
= cinfo
->spath
;
592 char *dpath
= cinfo
->dpath
;
595 r
= pthread_detach(pthread_self());
597 pthread_cond_init(&cinfo
->cond
, NULL
);
598 pthread_mutex_lock(&MasterMutex
);
599 cinfo
->r
+= DoCopy(cinfo
, 0);
600 /* cinfo arguments invalid on return */
601 --cinfo
->parent
->children
;
603 pthread_cond_signal(&cinfo
->parent
->cond
);
607 pthread_cond_destroy(&cinfo
->cond
);
609 hcc_free_trans(&SrcHost
);
610 hcc_free_trans(&DstHost
);
611 pthread_mutex_unlock(&MasterMutex
);
618 DoCopy(copy_info_t info
, int depth
)
620 const char *spath
= info
->spath
;
621 const char *dpath
= info
->dpath
;
622 dev_t sdevNo
= info
->sdevNo
;
623 dev_t ddevNo
= info
->ddevNo
;
626 int r
, mres
, fres
, st2Valid
;
628 List
*list
= malloc(sizeof(List
));
632 r
= mres
= fres
= st2Valid
= 0;
636 if (hc_lstat(&SrcHost
, spath
, &st1
) != 0) {
640 st2
.st_mode
= 0; /* in case lstat fails */
641 st2
.st_flags
= 0; /* in case lstat fails */
642 if (dpath
&& hc_lstat(&DstHost
, dpath
, &st2
) == 0)
645 if (S_ISREG(st1
.st_mode
)) {
653 if (S_ISREG(st1
.st_mode
) && st1
.st_nlink
> 1 && dpath
) {
654 if ((hln
= hltlookup(&st1
)) != NULL
) {
658 if (st2
.st_ino
== hln
->dino
) {
660 * hard link is already correct, nothing to do
663 logstd("%-32s nochange\n", (dpath
) ? dpath
: spath
);
664 if (hln
->nlinked
== st1
.st_nlink
) {
673 * hard link is not correct, attempt to unlink it
675 if (hc_remove(&DstHost
, dpath
) < 0) {
676 logerr("%-32s hardlink: unable to unlink: %s\n",
677 ((dpath
) ? dpath
: spath
), strerror(errno
));
686 if (xlink(hln
->name
, dpath
, st1
.st_flags
) < 0) {
687 int tryrelink
= (errno
== EMLINK
);
688 logerr("%-32s hardlink: unable to link to %s: %s\n",
689 (dpath
? dpath
: spath
), hln
->name
, strerror(errno
)
694 logerr("%-20s hardlink: will attempt to copy normally\n");
699 if (hln
->nlinked
== st1
.st_nlink
) {
705 logstd("%-32s hardlink: %s\n",
706 (dpath
? dpath
: spath
),
707 (st2Valid
? "relinked" : "linked")
718 * first instance of hardlink must be copied normally
721 hln
= hltadd(&st1
, dpath
);
726 * Do we need to copy the file/dir/link/whatever? Early termination
727 * if we do not. Always redo links. Directories are always traversed
728 * except when the FSMID options are used.
730 * NOTE: st2Valid is true only if dpath != NULL *and* dpath stats good.
735 && st1
.st_mode
== st2
.st_mode
736 #ifdef _ST_FLAGS_PRESENT_
737 && st1
.st_flags
== st2
.st_flags
740 if (S_ISLNK(st1
.st_mode
) || S_ISDIR(st1
.st_mode
)) {
742 * If FSMID tracking is turned on we can avoid recursing through
743 * an entire directory subtree if the FSMID matches.
745 #ifdef _ST_FSMID_PRESENT_
747 (UseFSMIDOpt
&& (fres
= fsmid_check(st1
.st_fsmid
, dpath
)) == 0)
749 if (VerboseOpt
>= 3) {
751 logstd("%-32s fsmid-nochange\n", (dpath
? dpath
: spath
));
753 logstd("%-32s nochange\n", (dpath
? dpath
: spath
));
761 st1
.st_size
== st2
.st_size
&&
762 st1
.st_uid
== st2
.st_uid
&&
763 st1
.st_gid
== st2
.st_gid
&&
764 st1
.st_mtime
== st2
.st_mtime
766 && (UseMD5Opt
== 0 || !S_ISREG(st1
.st_mode
) ||
767 (mres
= md5_check(spath
, dpath
)) == 0)
769 #ifdef _ST_FSMID_PRESENT_
770 && (UseFSMIDOpt
== 0 ||
771 (fres
= fsmid_check(st1
.st_fsmid
, dpath
)) == 0)
773 && (ValidateOpt
== 0 || !S_ISREG(st1
.st_mode
) ||
774 validate_check(spath
, dpath
) == 0)
777 hltsetdino(hln
, st2
.st_ino
);
778 if (VerboseOpt
>= 3) {
781 logstd("%-32s md5-nochange\n", (dpath
? dpath
: spath
));
785 logstd("%-32s fsmid-nochange\n", (dpath
? dpath
: spath
));
786 else if (ValidateOpt
)
787 logstd("%-32s nochange (contents validated)\n", (dpath
? dpath
: spath
));
789 logstd("%-32s nochange\n", (dpath
? dpath
: spath
));
791 CountSourceBytes
+= size
;
798 if (st2Valid
&& !S_ISDIR(st1
.st_mode
) && S_ISDIR(st2
.st_mode
)) {
800 logerr("%-32s SAFETY - refusing to copy file over directory\n",
801 (dpath
? dpath
: spath
)
805 goto done
; /* continue with the cpdup anyway */
807 if (QuietOpt
== 0 || AskConfirmation
) {
808 logstd("%-32s WARNING: non-directory source will blow away\n"
809 "%-32s preexisting dest directory, continuing anyway!\n",
810 ((dpath
) ? dpath
: spath
), "");
813 RemoveRecur(dpath
, ddevNo
);
817 * The various comparisons failed, copy it.
819 if (S_ISDIR(st1
.st_mode
)) {
823 logerr("%-32s/ fsmid-CHECK-FAILED\n", (dpath
) ? dpath
: spath
);
824 if ((dir
= hc_opendir(&SrcHost
, spath
)) != NULL
) {
829 if (S_ISDIR(st2
.st_mode
) == 0) {
830 hc_remove(&DstHost
, dpath
);
831 if (hc_mkdir(&DstHost
, dpath
, st1
.st_mode
| 0700) != 0) {
832 logerr("%s: mkdir failed: %s\n",
833 (dpath
? dpath
: spath
), strerror(errno
));
838 * Matt: why don't you check error codes here?
840 hc_lstat(&DstHost
, dpath
, &st2
);
841 hc_chown(&DstHost
, dpath
, st1
.st_uid
, st1
.st_gid
);
845 * Directory must be scanable by root for cpdup to
846 * work. We'll fix it later if the directory isn't
847 * supposed to be readable ( which is why we fixup
848 * st2.st_mode to match what we did ).
850 if ((st2
.st_mode
& 0700) != 0700) {
851 hc_chmod(&DstHost
, dpath
, st2
.st_mode
| 0700);
855 logstd("%s\n", dpath
? dpath
: spath
);
859 if ((int)sdevNo
>= 0 && st1
.st_dev
!= sdevNo
) {
865 if ((int)ddevNo
>= 0 && st2
.st_dev
!= ddevNo
) {
872 * scan .cpignore file for files/directories
878 char *buf
= malloc(GETBUFSIZE
);
881 if (UseCpFile
[0] == '/') {
882 fpath
= mprintf("%s", UseCpFile
);
884 fpath
= mprintf("%s/%s", spath
, UseCpFile
);
886 AddList(list
, strrchr(fpath
, '/') + 1, 1);
887 if ((fi
= fopen(fpath
, "r")) != NULL
) {
888 while (fgets(buf
, GETBUFSIZE
, fi
) != NULL
) {
890 CountSourceReadBytes
+= l
;
891 if (l
&& buf
[l
-1] == '\n')
893 if (buf
[0] && buf
[0] != '#')
894 AddList(list
, buf
, 1);
903 * Automatically exclude MD5CacheFile that we create on the
904 * source from the copy to the destination.
906 * Automatically exclude a FSMIDCacheFile on the source that
907 * would otherwise overwrite the one we maintain on the target.
910 AddList(list
, MD5CacheFile
, 1);
912 AddList(list
, FSMIDCacheFile
, 1);
914 while (noLoop
== 0 && (den
= hc_readdir(&SrcHost
, dir
)) != NULL
) {
921 if (strcmp(den
->d_name
, ".") == 0 ||
922 strcmp(den
->d_name
, "..") == 0
927 * ignore if on .cpignore list
929 if (AddList(list
, den
->d_name
, 0) == 1) {
932 nspath
= mprintf("%s/%s", spath
, den
->d_name
);
934 ndpath
= mprintf("%s/%s", dpath
, den
->d_name
);
937 if (CurParallel
< MaxParallel
|| depth
> MAXDEPTH
) {
938 copy_info_t cinfo
= malloc(sizeof(*cinfo
));
939 pthread_t dummy_thr
= NULL
;
941 bzero(cinfo
, sizeof(*cinfo
));
942 cinfo
->spath
= nspath
;
943 cinfo
->dpath
= ndpath
;
944 cinfo
->sdevNo
= sdevNo
;
945 cinfo
->ddevNo
= ddevNo
;
946 cinfo
->parent
= info
;
949 pthread_create(&dummy_thr
, NULL
, DoCopyThread
, cinfo
);
953 info
->spath
= nspath
;
954 info
->dpath
= ndpath
;
955 info
->sdevNo
= sdevNo
;
956 info
->ddevNo
= ddevNo
;
958 r
+= DoCopy(info
, depth
);
960 r
+= DoCopy(info
, depth
+ 1);
969 hc_closedir(&SrcHost
, dir
);
973 * Wait for our children to finish
975 while (info
->children
) {
976 pthread_cond_wait(&info
->cond
, &MasterMutex
);
983 * Remove files/directories from destination that do not appear
986 if (dpath
&& (dir
= hc_opendir(&DstHost
, dpath
)) != NULL
) {
987 while (noLoop
== 0 && (den
= hc_readdir(&DstHost
, dir
)) != NULL
) {
991 if (strcmp(den
->d_name
, ".") == 0 ||
992 strcmp(den
->d_name
, "..") == 0
997 * If object does not exist in source or .cpignore
998 * then recursively remove it.
1000 if (AddList(list
, den
->d_name
, 3) == 3) {
1003 ndpath
= mprintf("%s/%s", dpath
, den
->d_name
);
1004 RemoveRecur(ndpath
, ddevNo
);
1008 hc_closedir(&DstHost
, dir
);
1012 struct timeval tv
[2];
1016 st1
.st_uid
!= st2
.st_uid
||
1017 st1
.st_gid
!= st2
.st_gid
1019 hc_chown(&DstHost
, dpath
, st1
.st_uid
, st1
.st_gid
);
1021 if (st2Valid
== 0 || st1
.st_mode
!= st2
.st_mode
) {
1022 hc_chmod(&DstHost
, dpath
, st1
.st_mode
);
1024 #ifdef _ST_FLAGS_PRESENT_
1025 if (st2Valid
== 0 || st1
.st_flags
!= st2
.st_flags
) {
1026 hc_chflags(&DstHost
, dpath
, st1
.st_flags
);
1031 st1
.st_mtime
!= st2
.st_mtime
1033 bzero(tv
, sizeof(tv
));
1034 tv
[0].tv_sec
= st1
.st_mtime
;
1035 tv
[1].tv_sec
= st1
.st_mtime
;
1036 hc_utimes(&DstHost
, dpath
, tv
);
1040 } else if (dpath
== NULL
) {
1042 * If dpath is NULL, we are just updating the MD5
1045 if (UseMD5Opt
&& S_ISREG(st1
.st_mode
)) {
1046 mres
= md5_check(spath
, NULL
);
1048 if (VerboseOpt
> 1) {
1050 logstd("%-32s md5-update\n", (dpath
) ? dpath
: spath
);
1052 logstd("%-32s md5-ok\n", (dpath
) ? dpath
: spath
);
1053 } else if (!QuietOpt
&& mres
< 0) {
1054 logstd("%-32s md5-update\n", (dpath
) ? dpath
: spath
);
1058 } else if (S_ISREG(st1
.st_mode
)) {
1064 path
= mprintf("%s.tmp%d", dpath
, (int)getpid());
1067 * Handle check failure message.
1071 logerr("%-32s md5-CHECK-FAILED\n", (dpath
) ? dpath
: spath
);
1075 logerr("%-32s fsmid-CHECK-FAILED\n", (dpath
) ? dpath
: spath
);
1078 * Not quite ready to do the copy yet. If UseHLPath is defined,
1079 * see if we can hardlink instead.
1081 * If we can hardlink, and the target exists, we have to remove it
1082 * first or the hardlink will fail. This can occur in a number of
1083 * situations but must typically when the '-f -H' combination is
1086 if (UseHLPath
&& (hpath
= checkHLPath(&st1
, spath
, dpath
)) != NULL
) {
1088 hc_remove(&DstHost
, dpath
);
1089 if (hc_link(&DstHost
, hpath
, dpath
) == 0) {
1092 logstd("%-32s hardlinked(-H)\n",
1093 (dpath
? dpath
: spath
));
1099 * Shucks, we may have hit a filesystem hard linking limit,
1100 * we have to copy instead.
1105 if ((fd1
= hc_open(&SrcHost
, spath
, O_RDONLY
, 0)) >= 0) {
1106 if ((fd2
= hc_open(&DstHost
, path
, O_WRONLY
|O_CREAT
|O_EXCL
, 0600)) < 0) {
1108 * There could be a .tmp file from a previously interrupted
1109 * run, delete and retry. Fail if we still can't get at it.
1111 #ifdef _ST_FLAGS_PRESENT_
1112 hc_chflags(&DstHost
, path
, 0);
1114 hc_remove(&DstHost
, path
);
1115 fd2
= hc_open(&DstHost
, path
, O_WRONLY
|O_CREAT
|O_EXCL
|O_TRUNC
, 0600);
1119 char *iobuf1
= malloc(GETIOSIZE
);
1123 * Matt: What about holes?
1126 while ((n
= hc_read(&SrcHost
, fd1
, iobuf1
, GETIOSIZE
)) > 0) {
1128 if (hc_write(&DstHost
, fd2
, iobuf1
, n
) != n
)
1132 hc_close(&DstHost
, fd2
);
1134 struct timeval tv
[2];
1136 bzero(tv
, sizeof(tv
));
1137 tv
[0].tv_sec
= st1
.st_mtime
;
1138 tv
[1].tv_sec
= st1
.st_mtime
;
1140 hc_utimes(&DstHost
, path
, tv
);
1141 hc_chown(&DstHost
, path
, st1
.st_uid
, st1
.st_gid
);
1142 hc_chmod(&DstHost
, path
, st1
.st_mode
);
1143 if (xrename(path
, dpath
, st2
.st_flags
) != 0) {
1144 logerr("%-32s rename-after-copy failed: %s\n",
1145 (dpath
? dpath
: spath
), strerror(errno
)
1150 logstd("%-32s copy-ok\n", (dpath
? dpath
: spath
));
1151 #ifdef _ST_FLAGS_PRESENT_
1153 hc_chflags(&DstHost
, dpath
, st1
.st_flags
);
1156 CountSourceReadBytes
+= size
;
1157 CountWriteBytes
+= size
;
1158 CountSourceBytes
+= size
;
1162 logerr("%-32s %s failed: %s\n",
1163 (dpath
? dpath
: spath
), op
, strerror(errno
)
1165 hc_remove(&DstHost
, path
);
1170 logerr("%-32s create (uid %d, euid %d) failed: %s\n",
1171 (dpath
? dpath
: spath
), getuid(), geteuid(),
1176 hc_close(&SrcHost
, fd1
);
1178 logerr("%-32s copy: open failed: %s\n",
1179 (dpath
? dpath
: spath
),
1188 if (!r
&& hc_stat(&DstHost
, dpath
, &st2
) == 0) {
1189 hltsetdino(hln
, st2
.st_ino
);
1195 } else if (S_ISLNK(st1
.st_mode
)) {
1196 char *link1
= malloc(GETLINKSIZE
);
1197 char *link2
= malloc(GETLINKSIZE
);
1198 char *path
= malloc(GETPATHSIZE
);
1202 snprintf(path
, GETPATHSIZE
, "%s.tmp%d", dpath
, (int)getpid());
1203 n1
= hc_readlink(&SrcHost
, spath
, link1
, GETLINKSIZE
- 1);
1204 n2
= hc_readlink(&DstHost
, dpath
, link2
, GETLINKSIZE
- 1);
1206 if (ForceOpt
|| n1
!= n2
|| bcmp(link1
, link2
, n1
) != 0) {
1207 hc_umask(&DstHost
, ~st1
.st_mode
);
1208 hc_remove(&DstHost
, path
);
1210 if (hc_symlink(&DstHost
, link1
, path
) < 0) {
1211 logerr("%-32s symlink (%s->%s) failed: %s\n",
1212 (dpath
? dpath
: spath
), link1
, path
,
1217 hc_lchown(&DstHost
, path
, st1
.st_uid
, st1
.st_gid
);
1219 * there is no lchmod() or lchflags(), we
1220 * cannot chmod or chflags a softlink.
1222 if (xrename(path
, dpath
, st2
.st_flags
) != 0) {
1223 logerr("%-32s rename softlink (%s->%s) failed: %s\n",
1224 (dpath
? dpath
: spath
),
1225 path
, dpath
, strerror(errno
));
1226 } else if (VerboseOpt
) {
1227 logstd("%-32s softlink-ok\n", (dpath
? dpath
: spath
));
1229 hc_umask(&DstHost
, 000);
1230 CountWriteBytes
+= n1
;
1234 if (VerboseOpt
>= 3)
1235 logstd("%-32s nochange\n", (dpath
? dpath
: spath
));
1237 CountSourceBytes
+= n1
;
1238 CountSourceReadBytes
+= n1
;
1240 CountTargetReadBytes
+= n2
;
1244 logerr("%-32s softlink-failed\n", (dpath
? dpath
: spath
));
1249 } else if ((S_ISCHR(st1
.st_mode
) || S_ISBLK(st1
.st_mode
)) && DeviceOpt
) {
1250 char *path
= malloc(GETPATHSIZE
);
1254 st1
.st_mode
!= st2
.st_mode
||
1255 st1
.st_rdev
!= st2
.st_rdev
||
1256 st1
.st_uid
!= st2
.st_uid
||
1257 st1
.st_gid
!= st2
.st_gid
1259 snprintf(path
, GETPATHSIZE
, "%s.tmp%d", dpath
, (int)getpid());
1261 hc_remove(&DstHost
, path
);
1262 if (hc_mknod(&DstHost
, path
, st1
.st_mode
, st1
.st_rdev
) == 0) {
1263 hc_chmod(&DstHost
, path
, st1
.st_mode
);
1264 hc_chown(&DstHost
, path
, st1
.st_uid
, st1
.st_gid
);
1265 hc_remove(&DstHost
, dpath
);
1266 if (xrename(path
, dpath
, st2
.st_flags
) != 0) {
1267 logerr("%-32s dev-rename-after-create failed: %s\n",
1268 (dpath
? dpath
: spath
),
1271 } else if (VerboseOpt
) {
1272 logstd("%-32s dev-ok\n", (dpath
? dpath
: spath
));
1277 logerr("%-32s dev failed: %s\n",
1278 (dpath
? dpath
: spath
), strerror(errno
)
1282 if (VerboseOpt
>= 3)
1283 logstd("%-32s nochange\n", (dpath
? dpath
: spath
));
1290 if (hln
->dino
== (ino_t
)-1) {
1292 /*hln = NULL; unneeded */
1307 RemoveRecur(const char *dpath
, dev_t devNo
)
1311 if (hc_lstat(&DstHost
, dpath
, &st
) == 0) {
1314 if (st
.st_dev
== devNo
) {
1315 if (S_ISDIR(st
.st_mode
)) {
1318 if ((dir
= hc_opendir(&DstHost
, dpath
)) != NULL
) {
1320 while ((den
= hc_readdir(&DstHost
, dir
)) != NULL
) {
1323 if (strcmp(den
->d_name
, ".") == 0)
1325 if (strcmp(den
->d_name
, "..") == 0)
1327 ndpath
= mprintf("%s/%s", dpath
, den
->d_name
);
1328 RemoveRecur(ndpath
, devNo
);
1331 hc_closedir(&DstHost
, dir
);
1333 if (AskConfirmation
&& NoRemoveOpt
== 0) {
1335 if (hc_rmdir(&DstHost
, dpath
) < 0) {
1336 logerr("%-32s rmdir failed: %s\n",
1337 dpath
, strerror(errno
)
1340 CountRemovedItems
++;
1345 logstd("%-32s not-removed\n", dpath
);
1346 } else if (hc_rmdir(&DstHost
, dpath
) == 0) {
1348 logstd("%-32s rmdir-ok\n", dpath
);
1349 CountRemovedItems
++;
1351 logerr("%-32s rmdir failed: %s\n",
1352 dpath
, strerror(errno
)
1357 if (AskConfirmation
&& NoRemoveOpt
== 0) {
1359 if (hc_remove(&DstHost
, dpath
) < 0) {
1360 logerr("%-32s remove failed: %s\n",
1361 dpath
, strerror(errno
)
1364 CountRemovedItems
++;
1369 logstd("%-32s not-removed\n", dpath
);
1370 } else if (hc_remove(&DstHost
, dpath
) == 0) {
1372 logstd("%-32s remove-ok\n", dpath
);
1373 CountRemovedItems
++;
1375 logerr("%-32s remove failed: %s\n",
1376 dpath
, strerror(errno
)
1386 InitList(List
*list
)
1388 bzero(list
, sizeof(List
));
1389 list
->li_Node
.no_Next
= &list
->li_Node
;
1393 ResetList(List
*list
)
1397 while ((node
= list
->li_Node
.no_Next
) != &list
->li_Node
) {
1398 list
->li_Node
.no_Next
= node
->no_Next
;
1405 AddList(List
*list
, const char *name
, int n
)
1413 * Scan against wildcards. Only a node value of 1 can be a wildcard
1414 * ( usually scanned from .cpignore )
1417 for (node
= list
->li_Hash
[0]; node
; node
= node
->no_HNext
) {
1418 if (strcmp(name
, node
->no_Name
) == 0 ||
1419 (n
!= 1 && node
->no_Value
== 1 && WildCmp(node
->no_Name
, name
) == 0)
1421 return(node
->no_Value
);
1426 * Look for exact match
1429 for (node
= list
->li_Hash
[hv
]; node
; node
= node
->no_HNext
) {
1430 if (strcmp(name
, node
->no_Name
) == 0) {
1431 return(node
->no_Value
);
1434 node
= malloc(sizeof(Node
) + strlen(name
) + 1);
1436 fprintf(stderr
, "out of memory\n");
1440 node
->no_Next
= list
->li_Node
.no_Next
;
1441 list
->li_Node
.no_Next
= node
;
1443 node
->no_HNext
= list
->li_Hash
[hv
];
1444 list
->li_Hash
[hv
] = node
;
1446 strcpy(node
->no_Name
, name
);
1453 shash(const char *s
)
1460 if (*s
== '*' || *s
== '?' ||
1461 *s
== '{' || *s
== '}' ||
1462 *s
== '[' || *s
== ']' ||
1467 hv
= (hv
<< 5) ^ *s
^ (hv
>> 23);
1470 return(((hv
>> 16) ^ hv
) & HMASK
);
1474 * WildCmp() - compare wild string to sane string
1476 * Return 0 on success, -1 on failure.
1480 WildCmp(const char *w
, const char *s
)
1483 * skip fixed portion
1489 if (w
[1] == 0) /* optimize wild* case */
1495 for (i
= 0; i
<= l
; ++i
) {
1496 if (WildCmp(w
+ 1, s
+ i
) == 0)
1510 if (*w
== 0) /* terminator */
1522 YesNo(const char *path
)
1526 fprintf(stderr
, "remove %s (Yes/No) [No]? ", path
);
1529 first
= ch
= getchar();
1530 while (ch
!= '\n' && ch
!= EOF
)
1532 return ((first
== 'y' || first
== 'Y'));
1536 * xrename() - rename with override
1538 * If the rename fails, attempt to override st_flags on the
1539 * destination and rename again. If that fails too, try to
1540 * set the flags back the way they were and give up.
1544 xrename(const char *src
, const char *dst
, u_long flags
)
1550 if ((r
= hc_rename(&DstHost
, src
, dst
)) < 0) {
1551 #ifdef _ST_FLAGS_PRESENT_
1552 hc_chflags(&DstHost
, dst
, 0);
1553 if ((r
= hc_rename(&DstHost
, src
, dst
)) < 0)
1554 hc_chflags(&DstHost
, dst
, flags
);
1561 xlink(const char *src
, const char *dst
, u_long flags
)
1564 #ifdef _ST_FLAGS_PRESENT_
1570 if ((r
= hc_link(&DstHost
, src
, dst
)) < 0) {
1571 #ifdef _ST_FLAGS_PRESENT_
1572 hc_chflags(&DstHost
, src
, 0);
1573 r
= hc_link(&DstHost
, src
, dst
);
1575 hc_chflags(&DstHost
, src
, flags
);