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;
40 /* choose whether to skip a particular file */
41 static int skip_file(char *fname,
42 struct file_struct *file, STRUCT_STAT *st)
44 if (st->st_size != file->length) {
48 /* if always checksum is set then we use the checksum instead
49 of the file time to determine whether to sync */
50 if (always_checksum && S_ISREG(st->st_mode)) {
51 char sum[MD4_SUM_LENGTH];
52 file_checksum(fname,sum,st->st_size);
53 if (remote_version < 21) {
54 return (memcmp(sum,file->sum,2) == 0);
56 return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
68 return (st->st_mtime == file->modtime);
72 /* use a larger block size for really big files */
73 static int adapt_block_size(struct file_struct *file, int bsize)
77 if (bsize != BLOCK_SIZE) return bsize;
79 ret = file->length / (10000); /* rough heuristic */
80 ret = ret & ~15; /* multiple of 16 */
81 if (ret < bsize) ret = bsize;
82 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
88 send a sums struct down a fd
90 static void send_sums(struct sum_struct *s,int f_out)
94 /* tell the other guy how many we are going to be doing and how many
95 bytes there are in the last chunk */
96 write_int(f_out,s?s->count:0);
97 write_int(f_out,s?s->n:block_size);
98 write_int(f_out,s?s->remainder:0);
102 for (i=0;i<s->count;i++) {
103 write_int(f_out,s->sums[i].sum1);
104 write_buf(f_out,s->sums[i].sum2,csum_length);
110 generate a stream of signatures/checksums that describe a buffer
112 generate approximately one checksum every n bytes
114 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
117 struct sum_struct *s;
120 int remainder = (len%block_len);
123 count = (len+(block_len-1))/block_len;
125 s = (struct sum_struct *)malloc(sizeof(*s));
126 if (!s) out_of_memory("generate_sums");
129 s->remainder = remainder;
139 rprintf(FINFO,"count=%d rem=%d n=%d flength=%.0f\n",
140 s->count,s->remainder,s->n,(double)s->flength);
142 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
143 if (!s->sums) out_of_memory("generate_sums");
145 for (i=0;i<count;i++) {
147 char *map = map_ptr(buf,offset,n1);
149 s->sums[i].sum1 = get_checksum1(map,n1);
150 get_checksum2(map,n1,s->sums[i].sum2);
152 s->sums[i].offset = offset;
157 rprintf(FINFO,"chunk[%d] offset=%.0f len=%d sum1=%08x\n",
158 i,(double)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
168 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
172 struct map_struct *buf;
173 struct sum_struct *s;
175 struct file_struct *file = flist->files[i];
177 char fnamecmpbuf[MAXPATHLEN];
178 extern char *compare_dest;
179 extern int list_only;
180 extern int preserve_perms;
181 extern int only_existing;
183 if (list_only) return;
186 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
188 statret = link_stat(fname,&st);
190 if (only_existing && statret == -1 && errno == ENOENT) {
191 /* we only want to update existing files */
192 if (verbose > 1) rprintf(FINFO,"not creating %s\n",fname);
198 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
199 /* if the file exists already and we aren't perserving
200 presmissions then act as though the remote end sent
201 us the file permissions we already have */
202 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
205 if (S_ISDIR(file->mode)) {
207 if (statret == 0 && !S_ISDIR(st.st_mode)) {
208 if (robust_unlink(fname) != 0) {
209 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
214 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
215 if (!(relative_paths && errno==ENOENT &&
216 create_directory_path(fname)==0 &&
217 do_mkdir(fname,file->mode)==0)) {
218 rprintf(FERROR,"mkdir %s : %s (2)\n",
219 fname,strerror(errno));
222 if (set_perms(fname,file,NULL,0) && verbose)
223 rprintf(FINFO,"%s/\n",fname);
227 if (preserve_links && S_ISLNK(file->mode)) {
229 char lnk[MAXPATHLEN];
231 extern int safe_symlinks;
233 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
235 rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
241 l = readlink(fname,lnk,MAXPATHLEN-1);
244 if (strcmp(lnk,file->link) == 0) {
245 set_perms(fname,file,&st,1);
251 if (do_symlink(file->link,fname) != 0) {
252 rprintf(FERROR,"link %s -> %s : %s\n",
253 fname,file->link,strerror(errno));
255 set_perms(fname,file,NULL,0);
257 rprintf(FINFO,"%s -> %s\n",
266 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
268 st.st_mode != file->mode ||
269 st.st_rdev != file->rdev) {
272 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
273 fname,(int)file->mode,(int)file->rdev);
274 if (do_mknod(fname,file->mode,file->rdev) != 0) {
275 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
277 set_perms(fname,file,NULL,0);
279 rprintf(FINFO,"%s\n",fname);
282 set_perms(fname,file,&st,1);
288 if (preserve_hard_links && check_hard_link(file)) {
290 rprintf(FINFO,"%s is a hard link\n",f_name(file));
294 if (!S_ISREG(file->mode)) {
295 rprintf(FINFO,"skipping non-regular file %s\n",fname);
301 if ((statret == -1) && (compare_dest != NULL)) {
302 /* try the file at compare_dest instead */
303 int saveerrno = errno;
304 slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
305 statret = link_stat(fnamecmpbuf,&st);
306 if (!S_ISREG(st.st_mode))
311 fnamecmp = fnamecmpbuf;
315 if (errno == ENOENT) {
317 if (!dry_run) send_sums(NULL,f_out);
320 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
325 if (!S_ISREG(st.st_mode)) {
326 if (delete_file(fname) != 0) {
330 /* now pretend the file didn't exist */
332 if (!dry_run) send_sums(NULL,f_out);
336 if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) {
338 rprintf(FINFO,"%s is newer\n",fname);
342 if (skip_file(fname, file, &st)) {
343 if (fnamecmp == fname)
344 set_perms(fname,file,&st,1);
355 send_sums(NULL,f_out);
360 fd = do_open(fnamecmp, O_RDONLY, 0);
363 rprintf(FERROR,"failed to open %s, continuing : %s\n",fnamecmp,strerror(errno));
364 /* pretend the file didn't exist */
366 send_sums(NULL,f_out);
370 if (st.st_size > 0) {
371 buf = map_file(fd,st.st_size);
377 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
379 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
382 rprintf(FINFO,"sending sums for %d\n",i);
388 if (buf) unmap_file(buf);
395 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
401 rprintf(FINFO,"generator starting pid=%d count=%d\n",
402 (int)getpid(),flist->count);
404 for (i = 0; i < flist->count; i++) {
405 struct file_struct *file = flist->files[i];
406 mode_t saved_mode = file->mode;
407 if (!file->basename) continue;
409 /* we need to ensure that any directories we create have writeable
410 permissions initially so that we can create the files within
411 them. This is then fixed after the files are transferred */
412 if (!am_root && S_ISDIR(file->mode)) {
413 file->mode |= S_IWUSR; /* user write */
416 recv_generator(local_name?local_name:f_name(file),
419 file->mode = saved_mode;
423 csum_length = SUM_LENGTH;
427 rprintf(FINFO,"generate_files phase=%d\n",phase);
431 /* we expect to just sit around now, so don't exit on a
432 timeout. If we really get a timeout then the other process should
436 if (remote_version >= 13) {
437 /* in newer versions of the protocol the files can cycle through
438 the system more than once to catch initial checksum errors */
439 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
440 struct file_struct *file = flist->files[i];
441 recv_generator(local_name?local_name:f_name(file),
447 rprintf(FINFO,"generate_files phase=%d\n",phase);