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.
24 extern int relative_paths;
25 extern int preserve_links;
27 extern int preserve_devices;
28 extern int preserve_hard_links;
29 extern int update_only;
30 extern int whole_file;
31 extern int block_size;
32 extern int csum_length;
33 extern int ignore_times;
35 extern int io_timeout;
36 extern int remote_version;
37 extern int always_checksum;
38 extern char *compare_dest;
41 /* choose whether to skip a particular file */
42 static int skip_file(char *fname,
43 struct file_struct *file, STRUCT_STAT *st)
45 if (st->st_size != file->length) {
49 /* if always checksum is set then we use the checksum instead
50 of the file time to determine whether to sync */
51 if (always_checksum && S_ISREG(st->st_mode)) {
52 char sum[MD4_SUM_LENGTH];
53 char fnamecmpdest[MAXPATHLEN];
55 if (compare_dest != NULL) {
56 if (access(fname, 0) != 0) {
57 slprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
62 file_checksum(fname,sum,st->st_size);
63 if (remote_version < 21) {
64 return (memcmp(sum,file->sum,2) == 0);
66 return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
78 return (st->st_mtime == file->modtime);
82 /* use a larger block size for really big files */
83 static int adapt_block_size(struct file_struct *file, int bsize)
87 if (bsize != BLOCK_SIZE) return bsize;
89 ret = file->length / (10000); /* rough heuristic */
90 ret = ret & ~15; /* multiple of 16 */
91 if (ret < bsize) ret = bsize;
92 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
98 send a sums struct down a fd
100 static void send_sums(struct sum_struct *s,int f_out)
104 /* tell the other guy how many we are going to be doing and how many
105 bytes there are in the last chunk */
106 write_int(f_out,s?s->count:0);
107 write_int(f_out,s?s->n:block_size);
108 write_int(f_out,s?s->remainder:0);
112 for (i=0;i<s->count;i++) {
113 write_int(f_out,s->sums[i].sum1);
114 write_buf(f_out,s->sums[i].sum2,csum_length);
120 generate a stream of signatures/checksums that describe a buffer
122 generate approximately one checksum every n bytes
124 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
127 struct sum_struct *s;
130 int remainder = (len%block_len);
133 count = (len+(block_len-1))/block_len;
135 s = (struct sum_struct *)malloc(sizeof(*s));
136 if (!s) out_of_memory("generate_sums");
139 s->remainder = remainder;
149 rprintf(FINFO,"count=%d rem=%d n=%d flength=%.0f\n",
150 s->count,s->remainder,s->n,(double)s->flength);
152 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
153 if (!s->sums) out_of_memory("generate_sums");
155 for (i=0;i<count;i++) {
157 char *map = map_ptr(buf,offset,n1);
159 s->sums[i].sum1 = get_checksum1(map,n1);
160 get_checksum2(map,n1,s->sums[i].sum2);
162 s->sums[i].offset = offset;
167 rprintf(FINFO,"chunk[%d] offset=%.0f len=%d sum1=%08x\n",
168 i,(double)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
178 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
182 struct map_struct *buf;
183 struct sum_struct *s;
185 struct file_struct *file = flist->files[i];
187 char fnamecmpbuf[MAXPATHLEN];
188 extern char *compare_dest;
189 extern int list_only;
190 extern int preserve_perms;
191 extern int only_existing;
193 if (list_only) return;
196 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
198 statret = link_stat(fname,&st);
200 if (only_existing && statret == -1 && errno == ENOENT) {
201 /* we only want to update existing files */
202 if (verbose > 1) rprintf(FINFO,"not creating %s\n",fname);
208 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
209 /* if the file exists already and we aren't perserving
210 presmissions then act as though the remote end sent
211 us the file permissions we already have */
212 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
215 if (S_ISDIR(file->mode)) {
217 if (statret == 0 && !S_ISDIR(st.st_mode)) {
218 if (robust_unlink(fname) != 0) {
219 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
224 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
225 if (!(relative_paths && errno==ENOENT &&
226 create_directory_path(fname)==0 &&
227 do_mkdir(fname,file->mode)==0)) {
228 rprintf(FERROR,"mkdir %s : %s (2)\n",
229 fname,strerror(errno));
232 if (set_perms(fname,file,NULL,0) && verbose)
233 rprintf(FINFO,"%s/\n",fname);
237 if (preserve_links && S_ISLNK(file->mode)) {
239 char lnk[MAXPATHLEN];
241 extern int safe_symlinks;
243 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
245 rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
251 l = readlink(fname,lnk,MAXPATHLEN-1);
254 if (strcmp(lnk,file->link) == 0) {
255 set_perms(fname,file,&st,1);
261 if (do_symlink(file->link,fname) != 0) {
262 rprintf(FERROR,"symlink %s -> %s : %s\n",
263 fname,file->link,strerror(errno));
265 set_perms(fname,file,NULL,0);
267 rprintf(FINFO,"%s -> %s\n",
276 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
278 st.st_mode != file->mode ||
279 st.st_rdev != file->rdev) {
282 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
283 fname,(int)file->mode,(int)file->rdev);
284 if (do_mknod(fname,file->mode,file->rdev) != 0) {
285 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
287 set_perms(fname,file,NULL,0);
289 rprintf(FINFO,"%s\n",fname);
292 set_perms(fname,file,&st,1);
298 if (preserve_hard_links && check_hard_link(file)) {
300 rprintf(FINFO,"%s is a hard link\n",f_name(file));
304 if (!S_ISREG(file->mode)) {
305 rprintf(FINFO,"skipping non-regular file %s\n",fname);
311 if ((statret == -1) && (compare_dest != NULL)) {
312 /* try the file at compare_dest instead */
313 int saveerrno = errno;
314 slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
315 statret = link_stat(fnamecmpbuf,&st);
316 if (!S_ISREG(st.st_mode))
321 fnamecmp = fnamecmpbuf;
325 if (errno == ENOENT) {
327 if (!dry_run) send_sums(NULL,f_out);
330 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
335 if (!S_ISREG(st.st_mode)) {
336 if (delete_file(fname) != 0) {
340 /* now pretend the file didn't exist */
342 if (!dry_run) send_sums(NULL,f_out);
346 if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) {
348 rprintf(FINFO,"%s is newer\n",fname);
352 if (skip_file(fname, file, &st)) {
353 if (fnamecmp == fname)
354 set_perms(fname,file,&st,1);
365 send_sums(NULL,f_out);
370 fd = do_open(fnamecmp, O_RDONLY, 0);
373 rprintf(FERROR,"failed to open %s, continuing : %s\n",fnamecmp,strerror(errno));
374 /* pretend the file didn't exist */
376 send_sums(NULL,f_out);
380 if (st.st_size > 0) {
381 buf = map_file(fd,st.st_size);
387 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
389 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
392 rprintf(FINFO,"sending sums for %d\n",i);
398 if (buf) unmap_file(buf);
405 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
411 rprintf(FINFO,"generator starting pid=%d count=%d\n",
412 (int)getpid(),flist->count);
414 for (i = 0; i < flist->count; i++) {
415 struct file_struct *file = flist->files[i];
416 mode_t saved_mode = file->mode;
417 if (!file->basename) continue;
419 /* we need to ensure that any directories we create have writeable
420 permissions initially so that we can create the files within
421 them. This is then fixed after the files are transferred */
422 if (!am_root && S_ISDIR(file->mode)) {
423 file->mode |= S_IWUSR; /* user write */
426 recv_generator(local_name?local_name:f_name(file),
429 file->mode = saved_mode;
433 csum_length = SUM_LENGTH;
437 rprintf(FINFO,"generate_files phase=%d\n",phase);
441 /* we expect to just sit around now, so don't exit on a
442 timeout. If we really get a timeout then the other process should
446 if (remote_version >= 13) {
447 /* in newer versions of the protocol the files can cycle through
448 the system more than once to catch initial checksum errors */
449 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
450 struct file_struct *file = flist->files[i];
451 recv_generator(local_name?local_name:f_name(file),
457 rprintf(FINFO,"generate_files phase=%d\n",phase);