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",f_name(file));
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(f)) != 0) {
540 fprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
541 } else if (verbose) {
542 fprintf(FERROR,"deleting %s\n",f_name(f));
545 if (!dry_run && rmdir(f_name(f)) != 0) {
546 if (errno != ENOTEMPTY)
547 fprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
548 } else if (verbose) {
549 fprintf(FERROR,"deleting directory %s\n",f_name(f));
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(f_name(flist->files[j]));
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(f_name(flist->files[flist_up(flist, mid)]),name);
598 low = flist_up(flist, low);
600 if (strcmp(f_name(flist->files[low]),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 = f_name(flist->files[j]);
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]->basename) continue;
636 if (-1 == flist_find(flist,local_file_list->files[i])) {
637 delete_one(local_file_list->files[i]);
640 flist_free(local_file_list);
644 static char *cleanup_fname = NULL;
646 void exit_cleanup(int code)
649 unlink(cleanup_fname);
650 signal(SIGUSR1, SIG_IGN);
653 kill(-getpgrp(), SIGUSR1);
655 kill(-getpgrp(getpid()), SIGUSR1);
667 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
672 char fnametmp[MAXPATHLEN];
673 struct map_struct *buf;
675 struct file_struct *file;
680 fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
683 if (recurse && delete_mode && !local_name && flist->count>0) {
691 if (phase==0 && remote_version >= 13) {
693 csum_length = SUM_LENGTH;
695 fprintf(FERROR,"recv_files phase=%d\n",phase);
703 file = flist->files[i];
704 fname = f_name(file);
710 if (!am_server && verbose)
711 printf("%s\n",fname);
716 fprintf(FERROR,"recv_files(%s)\n",fname);
719 fd1 = open(fname,O_RDONLY);
721 if (fd1 != -1 && fstat(fd1,&st) != 0) {
722 fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
723 receive_data(f_in,NULL,-1,NULL);
728 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
729 fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
730 receive_data(f_in,NULL,-1,NULL);
735 if (fd1 != -1 && st.st_size > 0) {
736 buf = map_file(fd1,st.st_size);
738 fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
744 if (strlen(fname) > (MAXPATHLEN-8)) {
745 fprintf(FERROR,"filename too long\n");
746 if (buf) unmap_file(buf);
752 f = strrchr(fname,'/');
757 sprintf(fnametmp,"%s/%s.XXXXXX",tmpdir,f);
759 sprintf(fnametmp,"%s.XXXXXX",fname);
761 if (NULL == mktemp(fnametmp)) {
762 fprintf(FERROR,"mktemp %s failed\n",fnametmp);
763 receive_data(f_in,buf,-1,NULL);
764 if (buf) unmap_file(buf);
768 fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
769 if (fd2 == -1 && relative_paths && errno == ENOENT &&
770 create_directory_path(fnametmp) == 0) {
771 fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
774 fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
775 receive_data(f_in,buf,-1,NULL);
776 if (buf) unmap_file(buf);
781 cleanup_fname = fnametmp;
783 if (!am_server && verbose)
784 printf("%s\n",fname);
787 recv_ok = receive_data(f_in,buf,fd2,fname);
789 if (buf) unmap_file(buf);
796 fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
799 char fnamebak[MAXPATHLEN];
800 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
801 fprintf(FERROR,"backup filename too long\n");
804 sprintf(fnamebak,"%s%s",fname,backup_suffix);
805 if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
806 fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
811 /* move tmp file over real file */
812 if (rename(fnametmp,fname) != 0) {
813 if (errno == EXDEV) {
814 /* rename failed on cross-filesystem link.
815 Copy the file instead. */
816 if (copy_file(fnametmp,fname, file->mode)) {
817 fprintf(FERROR,"copy %s -> %s : %s\n",
818 fnametmp,fname,strerror(errno));
820 set_perms(fname,file,NULL,0);
824 fprintf(FERROR,"rename %s -> %s : %s\n",
825 fnametmp,fname,strerror(errno));
829 set_perms(fname,file,NULL,0);
832 cleanup_fname = NULL;
837 fprintf(FERROR,"redoing %s(%d)\n",fname,i);
838 if (csum_length == SUM_LENGTH)
839 fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
844 if (preserve_hard_links)
845 do_hard_links(flist);
847 /* now we need to fix any directory permissions that were
848 modified during the transfer */
849 for (i = 0; i < flist->count; i++) {
850 struct file_struct *file = flist->files[i];
851 if (!file->basename || !S_ISDIR(file->mode)) continue;
852 recv_generator(f_name(file),flist,i,-1);
856 fprintf(FERROR,"recv_files finished\n");
863 off_t send_files(struct file_list *flist,int f_out,int f_in)
866 struct sum_struct *s;
867 struct map_struct *buf;
869 char fname[MAXPATHLEN];
872 struct file_struct *file;
876 fprintf(FERROR,"send_files starting\n");
878 setup_nonblocking(f_in,f_out);
884 if (phase==0 && remote_version >= 13) {
886 csum_length = SUM_LENGTH;
890 fprintf(FERROR,"send_files phase=%d\n",phase);
896 file = flist->files[i];
900 strncpy(fname,file->basedir,MAXPATHLEN-1);
901 fname[MAXPATHLEN-1] = 0;
902 if (strlen(fname) == MAXPATHLEN-1) {
903 fprintf(FERROR, "send_files failed on long-named directory %s\n",
909 strncat(fname,f_name(file),MAXPATHLEN-strlen(fname));
912 fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
915 if (!am_server && verbose)
916 printf("%s\n",fname);
921 s = receive_sums(f_in);
923 fprintf(FERROR,"receive_sums failed\n");
927 fd = open(fname,O_RDONLY);
929 fprintf(FERROR,"send_files failed to open %s: %s\n",
930 fname,strerror(errno));
934 /* map the local file */
935 if (fstat(fd,&st) != 0) {
936 fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
941 if (st.st_size > 0) {
942 buf = map_file(fd,st.st_size);
948 fprintf(FERROR,"send_files mapped %s of size %d\n",
949 fname,(int)st.st_size);
953 write_int(f_out,s->count);
954 write_int(f_out,s->n);
955 write_int(f_out,s->remainder);
958 fprintf(FERROR,"calling match_sums %s\n",fname);
960 if (!am_server && verbose)
961 printf("%s\n",fname);
963 match_sums(f_out,s,buf,st.st_size);
966 if (buf) unmap_file(buf);
972 fprintf(FERROR,"sender finished %s\n",fname);
978 fprintf(FERROR,"send files finished\n");
990 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
996 fprintf(FERROR,"generator starting pid=%d count=%d\n",
997 (int)getpid(),flist->count);
999 for (i = 0; i < flist->count; i++) {
1000 struct file_struct *file = flist->files[i];
1001 mode_t saved_mode = file->mode;
1002 if (!file->basename) continue;
1004 /* we need to ensure that any directories we create have writeable
1005 permissions initially so that we can create the files within
1006 them. This is then fixed after the files are transferred */
1007 if (!am_root && S_ISDIR(file->mode)) {
1008 file->mode |= S_IWUSR; /* user write */
1011 recv_generator(local_name?local_name:f_name(file),
1014 file->mode = saved_mode;
1018 csum_length = SUM_LENGTH;
1022 fprintf(FERROR,"generate_files phase=%d\n",phase);
1027 if (remote_version >= 13) {
1028 /* in newer versions of the protocol the files can cycle through
1029 the system more than once to catch initial checksum errors */
1030 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1031 struct file_struct *file = flist->files[i];
1032 recv_generator(local_name?local_name:f_name(file),
1038 fprintf(FERROR,"generate_files phase=%d\n",phase);
1046 fprintf(FERROR,"generator wrote %d\n",write_total());