2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 extern int csum_length;
26 extern int always_checksum;
27 extern time_t starttime;
29 extern int remote_version;
31 extern char *backup_suffix;
34 extern int whole_file;
35 extern int block_size;
36 extern int update_only;
37 extern int make_backups;
38 extern int preserve_links;
39 extern int preserve_hard_links;
40 extern int preserve_perms;
41 extern int preserve_devices;
42 extern int preserve_uid;
43 extern int preserve_gid;
44 extern int preserve_times;
46 extern int ignore_times;
48 extern int delete_mode;
49 extern int cvs_exclude;
51 extern int relative_paths;
56 static void free_sums(struct sum_struct *s)
58 if (s->sums) free(s->sums);
65 send a sums struct down a fd
67 static void send_sums(struct sum_struct *s,int f_out)
71 /* tell the other guy how many we are going to be doing and how many
72 bytes there are in the last chunk */
73 write_int(f_out,s?s->count:0);
74 write_int(f_out,s?s->n:block_size);
75 write_int(f_out,s?s->remainder:0);
77 for (i=0;i<s->count;i++) {
78 write_int(f_out,s->sums[i].sum1);
79 write_buf(f_out,s->sums[i].sum2,csum_length);
86 generate a stream of signatures/checksums that describe a buffer
88 generate approximately one checksum every n bytes
90 static struct sum_struct *generate_sums(struct map_struct *buf,off_t len,int n)
96 int remainder = (len%block_len);
99 count = (len+(block_len-1))/block_len;
101 s = (struct sum_struct *)malloc(sizeof(*s));
102 if (!s) out_of_memory("generate_sums");
105 s->remainder = remainder;
115 fprintf(FERROR,"count=%d rem=%d n=%d flength=%d\n",
116 s->count,s->remainder,s->n,(int)s->flength);
118 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
119 if (!s->sums) out_of_memory("generate_sums");
121 for (i=0;i<count;i++) {
123 char *map = map_ptr(buf,offset,n1);
125 s->sums[i].sum1 = get_checksum1(map,n1);
126 get_checksum2(map,n1,s->sums[i].sum2);
128 s->sums[i].offset = offset;
133 fprintf(FERROR,"chunk[%d] offset=%d len=%d sum1=%08x\n",
134 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
145 receive the checksums for a buffer
147 static struct sum_struct *receive_sums(int f)
149 struct sum_struct *s;
153 s = (struct sum_struct *)malloc(sizeof(*s));
154 if (!s) out_of_memory("receive_sums");
156 s->count = read_int(f);
158 s->remainder = read_int(f);
162 fprintf(FERROR,"count=%d n=%d rem=%d\n",
163 s->count,s->n,s->remainder);
168 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
169 if (!s->sums) out_of_memory("receive_sums");
171 for (i=0;i<s->count;i++) {
172 s->sums[i].sum1 = read_int(f);
173 read_buf(f,s->sums[i].sum2,csum_length);
175 s->sums[i].offset = offset;
178 if (i == s->count-1 && s->remainder != 0) {
179 s->sums[i].len = s->remainder;
181 s->sums[i].len = s->n;
183 offset += s->sums[i].len;
186 fprintf(FERROR,"chunk[%d] len=%d offset=%d sum1=%08x\n",
187 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
196 static int set_perms(char *fname,struct file_struct *file,struct stat *st,
202 if (dry_run) return 0;
205 if (link_stat(fname,&st2) != 0) {
206 fprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
212 if (preserve_times && !S_ISLNK(st->st_mode) &&
213 st->st_mtime != file->modtime) {
215 if (set_modtime(fname,file->modtime) != 0) {
216 fprintf(FERROR,"failed to set times on %s : %s\n",
217 fname,strerror(errno));
223 if (preserve_perms && !S_ISLNK(st->st_mode) &&
224 st->st_mode != file->mode) {
226 if (chmod(fname,file->mode) != 0) {
227 fprintf(FERROR,"failed to set permissions on %s : %s\n",
228 fname,strerror(errno));
234 if ((am_root && preserve_uid && st->st_uid != file->uid) ||
235 (preserve_gid && st->st_gid != file->gid)) {
238 (am_root&&preserve_uid)?file->uid:-1,
239 preserve_gid?file->gid:-1) != 0) {
240 if (verbose>1 || preserve_uid)
241 fprintf(FERROR,"chown %s : %s\n",fname,strerror(errno));
246 if (verbose > 1 && report) {
248 fprintf(FINFO,"%s\n",fname);
250 fprintf(FINFO,"%s is uptodate\n",fname);
256 /* choose whether to skip a particular file */
257 static int skip_file(char *fname,
258 struct file_struct *file, struct stat *st)
260 if (st->st_size != file->length) {
264 /* if always checksum is set then we use the checksum instead
265 of the file time to determine whether to sync */
266 if (always_checksum && S_ISREG(st->st_mode)) {
267 char sum[MD4_SUM_LENGTH];
268 file_checksum(fname,sum,st->st_size);
269 return (memcmp(sum,file->sum,csum_length) == 0);
276 return (st->st_mtime == file->modtime);
280 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
284 struct map_struct *buf;
285 struct sum_struct *s;
287 struct file_struct *file = &flist->files[i];
290 fprintf(FERROR,"recv_generator(%s,%d)\n",fname,i);
292 statret = link_stat(fname,&st);
294 if (S_ISDIR(file->mode)) {
296 if (statret == 0 && !S_ISDIR(st.st_mode)) {
297 if (unlink(fname) != 0) {
298 fprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
303 if (statret != 0 && mkdir(fname,file->mode) != 0 && errno != EEXIST) {
304 if (!(relative_paths && errno==ENOENT &&
305 create_directory_path(fname)==0 &&
306 mkdir(fname,file->mode)==0)) {
307 fprintf(FERROR,"mkdir %s : %s (2)\n",
308 fname,strerror(errno));
311 if (set_perms(fname,file,NULL,0) && verbose)
312 fprintf(FINFO,"%s/\n",fname);
316 if (preserve_links && S_ISLNK(file->mode)) {
318 char lnk[MAXPATHLEN];
321 l = readlink(fname,lnk,MAXPATHLEN-1);
324 if (strcmp(lnk,file->link) == 0) {
325 set_perms(fname,file,&st,1);
330 if (!dry_run) unlink(fname);
331 if (!dry_run && symlink(file->link,fname) != 0) {
332 fprintf(FERROR,"link %s -> %s : %s\n",
333 fname,file->link,strerror(errno));
335 set_perms(fname,file,NULL,0);
337 fprintf(FINFO,"%s -> %s\n",
345 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
347 st.st_mode != file->mode ||
348 st.st_rdev != file->rdev) {
349 if (!dry_run) unlink(fname);
351 fprintf(FERROR,"mknod(%s,0%o,0x%x)\n",
352 fname,(int)file->mode,(int)file->rdev);
354 mknod(fname,file->mode,file->rdev) != 0) {
355 fprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
357 set_perms(fname,file,NULL,0);
359 fprintf(FINFO,"%s\n",fname);
362 set_perms(fname,file,&st,1);
368 if (preserve_hard_links && check_hard_link(file)) {
370 fprintf(FINFO,"%s is a hard link\n",file->name);
374 if (!S_ISREG(file->mode)) {
375 fprintf(FERROR,"skipping non-regular file %s\n",fname);
380 if (errno == ENOENT) {
382 if (!dry_run) send_sums(NULL,f_out);
385 fprintf(FERROR,"recv_generator failed to open %s\n",fname);
390 if (!S_ISREG(st.st_mode)) {
391 /* its not a regular file on the receiving end, but it is on the
392 sending end. If its a directory then skip it (too dangerous to
393 do a recursive deletion??) otherwise try to unlink it */
394 if (S_ISDIR(st.st_mode)) {
395 fprintf(FERROR,"ERROR: %s is a directory\n",fname);
398 if (unlink(fname) != 0) {
399 fprintf(FERROR,"%s : not a regular file (generator)\n",fname);
403 /* now pretend the file didn't exist */
405 if (!dry_run) send_sums(NULL,f_out);
409 if (update_only && st.st_mtime >= file->modtime) {
411 fprintf(FERROR,"%s is newer\n",fname);
415 if (skip_file(fname, file, &st)) {
416 set_perms(fname,file,&st,1);
427 send_sums(NULL,f_out);
432 fd = open(fname,O_RDONLY);
435 fprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
436 fprintf(FERROR,"skipping %s\n",fname);
440 if (st.st_size > 0) {
441 buf = map_file(fd,st.st_size);
447 fprintf(FERROR,"gen mapped %s of size %d\n",fname,(int)st.st_size);
449 s = generate_sums(buf,st.st_size,block_size);
452 fprintf(FERROR,"sending sums for %d\n",i);
459 if (buf) unmap_file(buf);
466 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
468 int i,n,remainder,len,count;
472 static char file_sum1[MD4_SUM_LENGTH];
473 static char file_sum2[MD4_SUM_LENGTH];
476 count = read_int(f_in);
478 remainder = read_int(f_in);
482 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
485 fprintf(FERROR,"data recv %d at %d\n",i,(int)offset);
489 if (fd != -1 && write_sparse(fd,data,i) != i) {
490 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
498 if (i == count-1 && remainder != 0)
502 fprintf(FERROR,"chunk[%d] of size %d at %d offset=%d\n",
503 i,len,(int)offset2,(int)offset);
505 map = map_ptr(buf,offset2,len);
510 if (fd != -1 && write_sparse(fd,map,len) != len) {
511 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
518 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
519 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
525 if (remote_version >= 14) {
526 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
528 fprintf(FERROR,"got file_sum\n");
529 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
536 static void delete_one(struct file_struct *f)
538 if (!S_ISDIR(f->mode)) {
539 if (!dry_run && unlink(f->name) != 0) {
540 fprintf(FERROR,"unlink %s : %s\n",f->name,strerror(errno));
541 } else if (verbose) {
542 fprintf(FERROR,"deleting %s\n",f->name);
545 if (!dry_run && rmdir(f->name) != 0) {
546 if (errno != ENOTEMPTY)
547 fprintf(FERROR,"rmdir %s : %s\n",f->name,strerror(errno));
548 } else if (verbose) {
549 fprintf(FERROR,"deleting directory %s\n",f->name);
555 /* yuck! This function wouldn't have been necessary if I had the sorting
556 algorithm right. Unfortunately fixing the sorting algorithm would introduce
557 a backward incompatibility as file list indexes are sent over the link.
559 The aim is to see if a directory has already had the deletion algorithm applied
560 to it (due to recursion), and if so to skip it. The bisection is to
561 prevent this being an n^2 algorithm */
562 static int delete_already_done(struct file_list *flist,int j)
568 if (j == 0) return 0;
570 name = strdup(flist->files[j].name);
573 fprintf(FERROR,"out of memory in delete_already_done");
577 p = strrchr(name,'/');
584 while (low != high) {
585 int mid = (low+high)/2;
586 int ret = strcmp(flist->files[flist_up(flist, mid)].name,name);
598 low = flist_up(flist, low);
600 if (strcmp(flist->files[low].name,name) == 0) {
610 /* this deletes any files on the receiving side that are not present
611 on the sending side. For version 1.6.4 I have changed the behaviour
612 to match more closely what most people seem to expect of this option */
613 static void delete_files(struct file_list *flist)
615 struct file_list *local_file_list;
621 for (j=0;j<flist->count;j++) {
622 char *name = flist->files[j].name;
624 if (!S_ISDIR(flist->files[j].mode)) continue;
626 if (delete_already_done(flist, j)) continue;
628 if (!(local_file_list = send_file_list(-1,1,&name)))
632 fprintf(FINFO,"deleting in %s\n", name);
634 for (i=local_file_list->count-1;i>=0;i--) {
635 if (!local_file_list->files[i].name) continue;
636 if (-1 == flist_find(flist,&local_file_list->files[i])) {
637 delete_one(&local_file_list->files[i]);
643 static char *cleanup_fname = NULL;
645 void exit_cleanup(int code)
648 unlink(cleanup_fname);
649 signal(SIGUSR1, SIG_IGN);
652 kill(-getpgrp(), SIGUSR1);
654 kill(-getpgrp(getpid()), SIGUSR1);
666 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
671 char fnametmp[MAXPATHLEN];
672 struct map_struct *buf;
674 struct file_struct *file;
679 fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
682 if (recurse && delete_mode && !local_name && flist->count>0) {
690 if (phase==0 && remote_version >= 13) {
692 csum_length = SUM_LENGTH;
694 fprintf(FERROR,"recv_files phase=%d\n",phase);
702 file = &flist->files[i];
709 if (!am_server && verbose)
710 printf("%s\n",fname);
715 fprintf(FERROR,"recv_files(%s)\n",fname);
718 fd1 = open(fname,O_RDONLY);
720 if (fd1 != -1 && fstat(fd1,&st) != 0) {
721 fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
722 receive_data(f_in,NULL,-1,NULL);
727 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
728 fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
729 receive_data(f_in,NULL,-1,NULL);
734 if (fd1 != -1 && st.st_size > 0) {
735 buf = map_file(fd1,st.st_size);
737 fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
743 if (strlen(fname) > (MAXPATHLEN-8)) {
744 fprintf(FERROR,"filename too long\n");
750 f = strrchr(fname,'/');
755 sprintf(fnametmp,"%s/%s.XXXXXX",tmpdir,f);
757 sprintf(fnametmp,"%s.XXXXXX",fname);
759 if (NULL == mktemp(fnametmp)) {
760 fprintf(FERROR,"mktemp %s failed\n",fnametmp);
761 receive_data(f_in,buf,-1,NULL);
762 if (buf) unmap_file(buf);
766 fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
767 if (fd2 == -1 && relative_paths && errno == ENOENT &&
768 create_directory_path(fnametmp) == 0) {
769 fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
772 fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
773 receive_data(f_in,buf,-1,NULL);
774 if (buf) unmap_file(buf);
779 cleanup_fname = fnametmp;
781 if (!am_server && verbose)
782 printf("%s\n",fname);
785 recv_ok = receive_data(f_in,buf,fd2,fname);
788 if (buf) unmap_file(buf);
794 fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
797 char fnamebak[MAXPATHLEN];
798 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
799 fprintf(FERROR,"backup filename too long\n");
802 sprintf(fnamebak,"%s%s",fname,backup_suffix);
803 if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
804 fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
809 /* move tmp file over real file */
810 if (rename(fnametmp,fname) != 0) {
811 if (errno == EXDEV) {
812 /* rename failed on cross-filesystem link.
813 Copy the file instead. */
814 if (copy_file(fnametmp,fname, file->mode)) {
815 fprintf(FERROR,"copy %s -> %s : %s\n",
816 fnametmp,fname,strerror(errno));
818 set_perms(fname,file,NULL,0);
822 fprintf(FERROR,"rename %s -> %s : %s\n",
823 fnametmp,fname,strerror(errno));
827 set_perms(fname,file,NULL,0);
830 cleanup_fname = NULL;
835 fprintf(FERROR,"redoing %s(%d)\n",fname,i);
836 if (csum_length == SUM_LENGTH)
837 fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
842 if (preserve_hard_links)
843 do_hard_links(flist);
845 /* now we need to fix any directory permissions that were
846 modified during the transfer */
847 for (i = 0; i < flist->count; i++) {
848 struct file_struct *file = &flist->files[i];
849 if (!file->name || !S_ISDIR(file->mode)) continue;
850 recv_generator(file->name,flist,i,-1);
854 fprintf(FERROR,"recv_files finished\n");
861 off_t send_files(struct file_list *flist,int f_out,int f_in)
864 struct sum_struct *s;
865 struct map_struct *buf;
867 char fname[MAXPATHLEN];
870 struct file_struct *file;
874 fprintf(FERROR,"send_files starting\n");
876 setup_nonblocking(f_in,f_out);
882 if (phase==0 && remote_version >= 13) {
884 csum_length = SUM_LENGTH;
888 fprintf(FERROR,"send_files phase=%d\n",phase);
894 file = &flist->files[i];
898 strncpy(fname,file->dir,MAXPATHLEN-1);
899 fname[MAXPATHLEN-1] = 0;
900 if (strlen(fname) == MAXPATHLEN-1) {
901 fprintf(FERROR, "send_files failed on long-named directory %s\n",
907 strncat(fname,file->name,MAXPATHLEN-strlen(fname));
910 fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
913 if (!am_server && verbose)
914 printf("%s\n",fname);
919 s = receive_sums(f_in);
921 fprintf(FERROR,"receive_sums failed\n");
925 fd = open(fname,O_RDONLY);
927 fprintf(FERROR,"send_files failed to open %s: %s\n",
928 fname,strerror(errno));
932 /* map the local file */
933 if (fstat(fd,&st) != 0) {
934 fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
939 if (st.st_size > 0) {
940 buf = map_file(fd,st.st_size);
946 fprintf(FERROR,"send_files mapped %s of size %d\n",
947 fname,(int)st.st_size);
951 write_int(f_out,s->count);
952 write_int(f_out,s->n);
953 write_int(f_out,s->remainder);
956 fprintf(FERROR,"calling match_sums %s\n",fname);
958 if (!am_server && verbose)
959 printf("%s\n",fname);
961 match_sums(f_out,s,buf,st.st_size);
964 if (buf) unmap_file(buf);
970 fprintf(FERROR,"sender finished %s\n",fname);
976 fprintf(FERROR,"send files finished\n");
988 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
994 fprintf(FERROR,"generator starting pid=%d count=%d\n",
995 (int)getpid(),flist->count);
997 for (i = 0; i < flist->count; i++) {
998 struct file_struct *file = &flist->files[i];
999 mode_t saved_mode = file->mode;
1000 if (!file->name) continue;
1002 /* we need to ensure that any directories we create have writeable
1003 permissions initially so that we can create the files within
1004 them. This is then fixed after the files are transferred */
1005 if (!am_root && S_ISDIR(file->mode)) {
1006 file->mode |= S_IWUSR; /* user write */
1009 recv_generator(local_name?local_name:file->name,
1012 file->mode = saved_mode;
1016 csum_length = SUM_LENGTH;
1020 fprintf(FERROR,"generate_files phase=%d\n",phase);
1025 if (remote_version >= 13) {
1026 /* in newer versions of the protocol the files can cycle through
1027 the system more than once to catch initial checksum errors */
1028 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1029 struct file_struct *file = &flist->files[i];
1030 recv_generator(local_name?local_name:file->name,
1036 fprintf(FERROR,"generate_files phase=%d\n",phase);
1044 fprintf(FERROR,"generator wrote %d\n",write_total());