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 int modify_window;
39 extern char *compare_dest;
42 /* choose whether to skip a particular file */
43 static int skip_file(char *fname,
44 struct file_struct *file, STRUCT_STAT *st)
46 if (st->st_size != file->length) {
50 /* if always checksum is set then we use the checksum instead
51 of the file time to determine whether to sync */
52 if (always_checksum && S_ISREG(st->st_mode)) {
53 char sum[MD4_SUM_LENGTH];
54 char fnamecmpdest[MAXPATHLEN];
56 if (compare_dest != NULL) {
57 if (access(fname, 0) != 0) {
58 slprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
63 file_checksum(fname,sum,st->st_size);
64 if (remote_version < 21) {
65 return (memcmp(sum,file->sum,2) == 0);
67 return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
79 return (cmp_modtime(st->st_mtime,file->modtime) == 0);
83 /* use a larger block size for really big files */
84 static int adapt_block_size(struct file_struct *file, int bsize)
88 if (bsize != BLOCK_SIZE) return bsize;
90 ret = file->length / (10000); /* rough heuristic */
91 ret = ret & ~15; /* multiple of 16 */
92 if (ret < bsize) ret = bsize;
93 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
99 send a sums struct down a fd
101 static void send_sums(struct sum_struct *s,int f_out)
105 /* tell the other guy how many we are going to be doing and how many
106 bytes there are in the last chunk */
107 write_int(f_out,s?s->count:0);
108 write_int(f_out,s?s->n:block_size);
109 write_int(f_out,s?s->remainder:0);
113 for (i=0;i<s->count;i++) {
114 write_int(f_out,s->sums[i].sum1);
115 write_buf(f_out,s->sums[i].sum2,csum_length);
121 generate a stream of signatures/checksums that describe a buffer
123 generate approximately one checksum every n bytes
125 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
128 struct sum_struct *s;
131 int remainder = (len%block_len);
134 count = (len+(block_len-1))/block_len;
136 s = (struct sum_struct *)malloc(sizeof(*s));
137 if (!s) out_of_memory("generate_sums");
140 s->remainder = remainder;
150 rprintf(FINFO,"count=%d rem=%d n=%d flength=%.0f\n",
151 s->count,s->remainder,s->n,(double)s->flength);
153 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
154 if (!s->sums) out_of_memory("generate_sums");
156 for (i=0;i<count;i++) {
158 char *map = map_ptr(buf,offset,n1);
160 s->sums[i].sum1 = get_checksum1(map,n1);
161 get_checksum2(map,n1,s->sums[i].sum2);
163 s->sums[i].offset = offset;
168 rprintf(FINFO,"chunk[%d] offset=%.0f len=%d sum1=%08x\n",
169 i,(double)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
179 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
183 struct map_struct *buf;
184 struct sum_struct *s;
186 struct file_struct *file = flist->files[i];
188 char fnamecmpbuf[MAXPATHLEN];
189 extern char *compare_dest;
190 extern int list_only;
191 extern int preserve_perms;
192 extern int only_existing;
194 if (list_only) return;
197 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
199 statret = link_stat(fname,&st);
201 if (only_existing && statret == -1 && errno == ENOENT) {
202 /* we only want to update existing files */
203 if (verbose > 1) rprintf(FINFO,"not creating %s\n",fname);
209 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
210 /* if the file exists already and we aren't perserving
211 presmissions then act as though the remote end sent
212 us the file permissions we already have */
213 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
216 if (S_ISDIR(file->mode)) {
218 if (statret == 0 && !S_ISDIR(st.st_mode)) {
219 if (robust_unlink(fname) != 0) {
220 rprintf(FERROR,"recv_generator: unlink %s: %s\n",fname,strerror(errno));
225 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
226 if (!(relative_paths && errno==ENOENT &&
227 create_directory_path(fname)==0 &&
228 do_mkdir(fname,file->mode)==0)) {
229 rprintf(FERROR,"recv_generator: mkdir %s: %s (2)\n",
230 fname,strerror(errno));
233 if (set_perms(fname,file,NULL,0) && verbose)
234 rprintf(FINFO,"%s/\n",fname);
238 if (preserve_links && S_ISLNK(file->mode)) {
240 char lnk[MAXPATHLEN];
242 extern int safe_symlinks;
244 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
246 rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
252 l = readlink(fname,lnk,MAXPATHLEN-1);
255 if (strcmp(lnk,file->link) == 0) {
256 set_perms(fname,file,&st,1);
262 if (do_symlink(file->link,fname) != 0) {
263 rprintf(FERROR,"symlink %s -> %s : %s\n",
264 fname,file->link,strerror(errno));
266 set_perms(fname,file,NULL,0);
268 rprintf(FINFO,"%s -> %s\n",
277 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
279 st.st_mode != file->mode ||
280 st.st_rdev != file->rdev) {
283 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
284 fname,(int)file->mode,(int)file->rdev);
285 if (do_mknod(fname,file->mode,file->rdev) != 0) {
286 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
288 set_perms(fname,file,NULL,0);
290 rprintf(FINFO,"%s\n",fname);
293 set_perms(fname,file,&st,1);
299 if (preserve_hard_links && check_hard_link(file)) {
301 rprintf(FINFO,"%s is a hard link\n",f_name(file));
305 if (!S_ISREG(file->mode)) {
306 rprintf(FINFO,"skipping non-regular file %s\n",fname);
312 if ((statret == -1) && (compare_dest != NULL)) {
313 /* try the file at compare_dest instead */
314 int saveerrno = errno;
315 slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
316 statret = link_stat(fnamecmpbuf,&st);
317 if (!S_ISREG(st.st_mode))
322 fnamecmp = fnamecmpbuf;
326 if (errno == ENOENT) {
328 if (!dry_run) send_sums(NULL,f_out);
331 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
336 if (!S_ISREG(st.st_mode)) {
337 if (delete_file(fname) != 0) {
341 /* now pretend the file didn't exist */
343 if (!dry_run) send_sums(NULL,f_out);
347 if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
349 rprintf(FINFO,"%s is newer\n",fname);
353 if (skip_file(fname, file, &st)) {
354 if (fnamecmp == fname)
355 set_perms(fname,file,&st,1);
366 send_sums(NULL,f_out);
371 fd = do_open(fnamecmp, O_RDONLY, 0);
374 rprintf(FERROR,"failed to open %s, continuing : %s\n",fnamecmp,strerror(errno));
375 /* pretend the file didn't exist */
377 send_sums(NULL,f_out);
381 if (st.st_size > 0) {
382 buf = map_file(fd,st.st_size);
388 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
390 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
393 rprintf(FINFO,"sending sums for %d\n",i);
399 if (buf) unmap_file(buf);
406 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
412 rprintf(FINFO,"generator starting pid=%d count=%d\n",
413 (int)getpid(),flist->count);
415 for (i = 0; i < flist->count; i++) {
416 struct file_struct *file = flist->files[i];
417 mode_t saved_mode = file->mode;
418 if (!file->basename) continue;
420 /* we need to ensure that any directories we create have writeable
421 permissions initially so that we can create the files within
422 them. This is then fixed after the files are transferred */
423 if (!am_root && S_ISDIR(file->mode)) {
424 file->mode |= S_IWUSR; /* user write */
427 recv_generator(local_name?local_name:f_name(file),
430 file->mode = saved_mode;
434 csum_length = SUM_LENGTH;
438 rprintf(FINFO,"generate_files phase=%d\n",phase);
442 /* we expect to just sit around now, so don't exit on a
443 timeout. If we really get a timeout then the other process should
447 if (remote_version >= 13) {
448 /* in newer versions of the protocol the files can cycle through
449 the system more than once to catch initial checksum errors */
450 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
451 struct file_struct *file = flist->files[i];
452 recv_generator(local_name?local_name:f_name(file),
458 rprintf(FINFO,"generate_files phase=%d\n",phase);