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;
33 extern int whole_file;
34 extern int block_size;
35 extern int update_only;
36 extern int make_backups;
37 extern int preserve_links;
38 extern int preserve_hard_links;
39 extern int preserve_perms;
40 extern int preserve_devices;
41 extern int preserve_uid;
42 extern int preserve_gid;
43 extern int preserve_times;
45 extern int ignore_times;
47 extern int delete_mode;
48 extern int cvs_exclude;
50 extern int relative_paths;
55 static void free_sums(struct sum_struct *s)
57 if (s->sums) free(s->sums);
64 send a sums struct down a fd
66 static void send_sums(struct sum_struct *s,int f_out)
70 /* tell the other guy how many we are going to be doing and how many
71 bytes there are in the last chunk */
72 write_int(f_out,s?s->count:0);
73 write_int(f_out,s?s->n:block_size);
74 write_int(f_out,s?s->remainder:0);
76 for (i=0;i<s->count;i++) {
77 write_int(f_out,s->sums[i].sum1);
78 write_buf(f_out,s->sums[i].sum2,csum_length);
85 generate a stream of signatures/checksums that describe a buffer
87 generate approximately one checksum every n bytes
89 static struct sum_struct *generate_sums(struct map_struct *buf,off_t len,int n)
95 int remainder = (len%block_len);
98 count = (len+(block_len-1))/block_len;
100 s = (struct sum_struct *)malloc(sizeof(*s));
101 if (!s) out_of_memory("generate_sums");
104 s->remainder = remainder;
114 fprintf(FERROR,"count=%d rem=%d n=%d flength=%d\n",
115 s->count,s->remainder,s->n,(int)s->flength);
117 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
118 if (!s->sums) out_of_memory("generate_sums");
120 for (i=0;i<count;i++) {
122 char *map = map_ptr(buf,offset,n1);
124 s->sums[i].sum1 = get_checksum1(map,n1);
125 get_checksum2(map,n1,s->sums[i].sum2);
127 s->sums[i].offset = offset;
132 fprintf(FERROR,"chunk[%d] offset=%d len=%d sum1=%08x\n",
133 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
144 receive the checksums for a buffer
146 static struct sum_struct *receive_sums(int f)
148 struct sum_struct *s;
152 s = (struct sum_struct *)malloc(sizeof(*s));
153 if (!s) out_of_memory("receive_sums");
155 s->count = read_int(f);
157 s->remainder = read_int(f);
161 fprintf(FERROR,"count=%d n=%d rem=%d\n",
162 s->count,s->n,s->remainder);
167 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
168 if (!s->sums) out_of_memory("receive_sums");
170 for (i=0;i<s->count;i++) {
171 s->sums[i].sum1 = read_int(f);
172 read_buf(f,s->sums[i].sum2,csum_length);
174 s->sums[i].offset = offset;
177 if (i == s->count-1 && s->remainder != 0) {
178 s->sums[i].len = s->remainder;
180 s->sums[i].len = s->n;
182 offset += s->sums[i].len;
185 fprintf(FERROR,"chunk[%d] len=%d offset=%d sum1=%08x\n",
186 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
195 static int set_perms(char *fname,struct file_struct *file,struct stat *st,
201 if (dry_run) return 0;
204 if (link_stat(fname,&st2) != 0) {
205 fprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
211 if (preserve_times && !S_ISLNK(st->st_mode) &&
212 st->st_mtime != file->modtime) {
214 if (set_modtime(fname,file->modtime) != 0) {
215 fprintf(FERROR,"failed to set times on %s : %s\n",
216 fname,strerror(errno));
222 if (preserve_perms && !S_ISLNK(st->st_mode) &&
223 st->st_mode != file->mode) {
225 if (chmod(fname,file->mode) != 0) {
226 fprintf(FERROR,"failed to set permissions on %s : %s\n",
227 fname,strerror(errno));
233 if ((am_root && preserve_uid && st->st_uid != file->uid) ||
234 (preserve_gid && st->st_gid != file->gid)) {
237 (am_root&&preserve_uid)?file->uid:-1,
238 preserve_gid?file->gid:-1) != 0) {
239 if (verbose>1 || preserve_uid)
240 fprintf(FERROR,"chown %s : %s\n",fname,strerror(errno));
245 if (verbose > 1 && report) {
247 fprintf(FINFO,"%s\n",fname);
249 fprintf(FINFO,"%s is uptodate\n",fname);
255 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
259 struct map_struct *buf;
260 struct sum_struct *s;
261 char sum[MD4_SUM_LENGTH];
263 struct file_struct *file = &flist->files[i];
266 fprintf(FERROR,"recv_generator(%s,%d)\n",fname,i);
268 statret = link_stat(fname,&st);
270 if (S_ISDIR(file->mode)) {
272 if (statret == 0 && !S_ISDIR(st.st_mode)) {
273 if (unlink(fname) != 0) {
274 fprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
279 if (statret != 0 && mkdir(fname,file->mode) != 0 && errno != EEXIST) {
280 if (!(relative_paths && errno==ENOENT &&
281 create_directory_path(fname)==0 &&
282 mkdir(fname,file->mode)==0)) {
283 fprintf(FERROR,"mkdir %s : %s (2)\n",
284 fname,strerror(errno));
287 if (set_perms(fname,file,NULL,0) && verbose)
288 fprintf(FINFO,"%s/\n",fname);
292 if (preserve_links && S_ISLNK(file->mode)) {
294 char lnk[MAXPATHLEN];
297 l = readlink(fname,lnk,MAXPATHLEN-1);
300 if (strcmp(lnk,file->link) == 0) {
301 set_perms(fname,file,&st,1);
306 if (!dry_run) unlink(fname);
307 if (!dry_run && symlink(file->link,fname) != 0) {
308 fprintf(FERROR,"link %s -> %s : %s\n",
309 fname,file->link,strerror(errno));
311 set_perms(fname,file,NULL,0);
313 fprintf(FINFO,"%s -> %s\n",
321 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
323 st.st_mode != file->mode ||
324 st.st_rdev != file->rdev) {
325 if (!dry_run) unlink(fname);
327 fprintf(FERROR,"mknod(%s,0%o,0x%x)\n",
328 fname,(int)file->mode,(int)file->rdev);
330 mknod(fname,file->mode,file->rdev) != 0) {
331 fprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
333 set_perms(fname,file,NULL,0);
335 fprintf(FINFO,"%s\n",fname);
338 set_perms(fname,file,&st,1);
344 if (preserve_hard_links && check_hard_link(file)) {
346 fprintf(FINFO,"%s is a hard link\n",file->name);
350 if (!S_ISREG(file->mode)) {
351 fprintf(FERROR,"skipping non-regular file %s\n",fname);
356 if (errno == ENOENT) {
358 if (!dry_run) send_sums(NULL,f_out);
361 fprintf(FERROR,"recv_generator failed to open %s\n",fname);
366 if (!S_ISREG(st.st_mode)) {
367 /* its not a regular file on the receiving end, but it is on the
368 sending end. If its a directory then skip it (too dangerous to
369 do a recursive deletion??) otherwise try to unlink it */
370 if (S_ISDIR(st.st_mode)) {
371 fprintf(FERROR,"ERROR: %s is a directory\n",fname);
374 if (unlink(fname) != 0) {
375 fprintf(FERROR,"%s : not a regular file (generator)\n",fname);
379 /* now pretend the file didn't exist */
381 if (!dry_run) send_sums(NULL,f_out);
385 if (update_only && st.st_mtime >= file->modtime) {
387 fprintf(FERROR,"%s is newer\n",fname);
391 if (always_checksum && S_ISREG(st.st_mode)) {
392 file_checksum(fname,sum,st.st_size);
395 if (st.st_size == file->length &&
396 ((!ignore_times && st.st_mtime == file->modtime) ||
397 (always_checksum && S_ISREG(st.st_mode) &&
398 memcmp(sum,file->sum,csum_length) == 0))) {
399 set_perms(fname,file,&st,1);
410 send_sums(NULL,f_out);
415 fd = open(fname,O_RDONLY);
418 fprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
419 fprintf(FERROR,"skipping %s\n",fname);
423 if (st.st_size > 0) {
424 buf = map_file(fd,st.st_size);
430 fprintf(FERROR,"gen mapped %s of size %d\n",fname,(int)st.st_size);
432 s = generate_sums(buf,st.st_size,block_size);
435 fprintf(FERROR,"sending sums for %d\n",i);
442 if (buf) unmap_file(buf);
449 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
451 int i,n,remainder,len,count;
455 static char file_sum1[MD4_SUM_LENGTH];
456 static char file_sum2[MD4_SUM_LENGTH];
459 count = read_int(f_in);
461 remainder = read_int(f_in);
465 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
468 fprintf(FERROR,"data recv %d at %d\n",i,(int)offset);
472 if (fd != -1 && write_sparse(fd,data,i) != i) {
473 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
481 if (i == count-1 && remainder != 0)
485 fprintf(FERROR,"chunk[%d] of size %d at %d offset=%d\n",
486 i,len,(int)offset2,(int)offset);
488 map = map_ptr(buf,offset2,len);
493 if (fd != -1 && write_sparse(fd,map,len) != len) {
494 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
501 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
502 fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
508 if (remote_version >= 14) {
509 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
511 fprintf(FERROR,"got file_sum\n");
512 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
519 static void delete_one(struct file_struct *f)
521 if (!S_ISDIR(f->mode)) {
522 if (!dry_run && unlink(f->name) != 0) {
523 fprintf(FERROR,"unlink %s : %s\n",f->name,strerror(errno));
524 } else if (verbose) {
525 fprintf(FERROR,"deleting %s\n",f->name);
528 if (!dry_run && rmdir(f->name) != 0) {
529 if (errno != ENOTEMPTY)
530 fprintf(FERROR,"rmdir %s : %s\n",f->name,strerror(errno));
531 } else if (verbose) {
532 fprintf(FERROR,"deleting directory %s\n",f->name);
538 /* this deletes any files on the receiving side that are not present
539 on the sending side. For version 1.6.4 I have changed the behaviour
540 to match more closely what most people seem to expect of this option */
541 static void delete_files(struct file_list *flist)
543 struct file_list *local_file_list;
545 char *last_name=NULL;
550 for (j=0;j<flist->count;j++) {
551 if (!S_ISDIR(flist->files[j].mode)) continue;
552 if (strcmp(flist->files[j].name,".")==0) continue;
554 flist->files[j].name[strlen(last_name)] == '/' &&
555 strncmp(flist->files[j].name,last_name, strlen(last_name))==0)
557 last_name = flist->files[j].name;
558 if (!(local_file_list = send_file_list(-1,1,&last_name)))
561 fprintf(FINFO,"deleting in %s\n", last_name);
563 for (i=local_file_list->count-1;i>=0;i--) {
564 if (!local_file_list->files[i].name) continue;
565 if (-1 == flist_find(flist,&local_file_list->files[i])) {
566 delete_one(&local_file_list->files[i]);
572 static char *cleanup_fname = NULL;
574 void exit_cleanup(int code)
577 unlink(cleanup_fname);
578 signal(SIGUSR1, SIG_IGN);
581 kill(-getpgrp(), SIGUSR1);
583 kill(-getpgrp(getpid()), SIGUSR1);
595 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
600 char fnametmp[MAXPATHLEN];
601 struct map_struct *buf;
603 struct file_struct *file;
608 fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
611 if (recurse && delete_mode && !local_name && flist->count>0) {
619 if (phase==0 && remote_version >= 13) {
621 csum_length = SUM_LENGTH;
623 fprintf(FERROR,"recv_files phase=%d\n",phase);
631 file = &flist->files[i];
638 if (!am_server && verbose)
639 printf("%s\n",fname);
644 fprintf(FERROR,"recv_files(%s)\n",fname);
647 fd1 = open(fname,O_RDONLY);
649 if (fd1 != -1 && fstat(fd1,&st) != 0) {
650 fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
651 receive_data(f_in,NULL,-1,NULL);
656 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
657 fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
658 receive_data(f_in,NULL,-1,NULL);
663 if (fd1 != -1 && st.st_size > 0) {
664 buf = map_file(fd1,st.st_size);
666 fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
672 if (strlen(fname) > (MAXPATHLEN-8)) {
673 fprintf(FERROR,"filename too long\n");
677 sprintf(fnametmp,"%s.XXXXXX",fname);
678 if (NULL == mktemp(fnametmp)) {
679 fprintf(FERROR,"mktemp %s failed\n",fnametmp);
680 receive_data(f_in,buf,-1,NULL);
681 if (buf) unmap_file(buf);
685 fd2 = open(fnametmp,O_WRONLY|O_CREAT,file->mode);
686 if (fd2 == -1 && relative_paths && errno == ENOENT &&
687 create_directory_path(fnametmp) == 0) {
688 fd2 = open(fnametmp,O_WRONLY|O_CREAT,file->mode);
691 fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
692 receive_data(f_in,buf,-1,NULL);
693 if (buf) unmap_file(buf);
698 cleanup_fname = fnametmp;
700 if (!am_server && verbose)
701 printf("%s\n",fname);
704 recv_ok = receive_data(f_in,buf,fd2,fname);
707 if (buf) unmap_file(buf);
713 fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
716 char fnamebak[MAXPATHLEN];
717 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
718 fprintf(FERROR,"backup filename too long\n");
721 sprintf(fnamebak,"%s%s",fname,backup_suffix);
722 if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
723 fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
728 /* move tmp file over real file */
729 if (rename(fnametmp,fname) != 0) {
730 fprintf(FERROR,"rename %s -> %s : %s\n",
731 fnametmp,fname,strerror(errno));
735 cleanup_fname = NULL;
737 set_perms(fname,file,NULL,0);
741 fprintf(FERROR,"redoing %s(%d)\n",fname,i);
742 if (csum_length == SUM_LENGTH)
743 fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
748 if (preserve_hard_links)
749 do_hard_links(flist);
751 /* now we need to fix any directory permissions that were
752 modified during the transfer */
753 for (i = 0; i < flist->count; i++) {
754 struct file_struct *file = &flist->files[i];
755 if (!file->name || !S_ISDIR(file->mode)) continue;
756 recv_generator(file->name,flist,i,-1);
760 fprintf(FERROR,"recv_files finished\n");
767 off_t send_files(struct file_list *flist,int f_out,int f_in)
770 struct sum_struct *s;
771 struct map_struct *buf;
773 char fname[MAXPATHLEN];
776 struct file_struct *file;
780 fprintf(FERROR,"send_files starting\n");
782 setup_nonblocking(f_in,f_out);
788 if (phase==0 && remote_version >= 13) {
790 csum_length = SUM_LENGTH;
794 fprintf(FERROR,"send_files phase=%d\n",phase);
800 file = &flist->files[i];
804 strncpy(fname,file->dir,MAXPATHLEN-1);
805 fname[MAXPATHLEN-1] = 0;
806 if (strlen(fname) == MAXPATHLEN-1) {
807 fprintf(FERROR, "send_files failed on long-named directory %s\n",
813 strncat(fname,file->name,MAXPATHLEN-strlen(fname));
816 fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
819 if (!am_server && verbose)
820 printf("%s\n",fname);
825 s = receive_sums(f_in);
827 fprintf(FERROR,"receive_sums failed\n");
831 fd = open(fname,O_RDONLY);
833 fprintf(FERROR,"send_files failed to open %s: %s\n",
834 fname,strerror(errno));
838 /* map the local file */
839 if (fstat(fd,&st) != 0) {
840 fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
845 if (st.st_size > 0) {
846 buf = map_file(fd,st.st_size);
852 fprintf(FERROR,"send_files mapped %s of size %d\n",
853 fname,(int)st.st_size);
857 write_int(f_out,s->count);
858 write_int(f_out,s->n);
859 write_int(f_out,s->remainder);
862 fprintf(FERROR,"calling match_sums %s\n",fname);
864 if (!am_server && verbose)
865 printf("%s\n",fname);
867 match_sums(f_out,s,buf,st.st_size);
870 if (buf) unmap_file(buf);
876 fprintf(FERROR,"sender finished %s\n",fname);
882 fprintf(FERROR,"send files finished\n");
894 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
900 fprintf(FERROR,"generator starting pid=%d count=%d\n",
901 (int)getpid(),flist->count);
903 for (i = 0; i < flist->count; i++) {
904 struct file_struct *file = &flist->files[i];
905 mode_t saved_mode = file->mode;
906 if (!file->name) continue;
908 /* we need to ensure that any directories we create have writeable
909 permissions initially so that we can create the files within
910 them. This is then fixed after the files are transferred */
911 if (!am_root && S_ISDIR(file->mode)) {
912 file->mode |= S_IWUSR; /* user write */
915 recv_generator(local_name?local_name:file->name,
918 file->mode = saved_mode;
922 csum_length = SUM_LENGTH;
926 fprintf(FERROR,"generate_files phase=%d\n",phase);
931 if (remote_version >= 13) {
932 /* in newer versions of the protocol the files can cycle through
933 the system more than once to catch initial checksum errors */
934 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
935 struct file_struct *file = &flist->files[i];
936 recv_generator(local_name?local_name:file->name,
942 fprintf(FERROR,"generate_files phase=%d\n",phase);
950 fprintf(FERROR,"generator wrote %d\n",write_total());