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;
34 extern int io_timeout;
35 extern int remote_version;
36 extern int always_checksum;
39 /* choose whether to skip a particular file */
40 static int skip_file(char *fname,
41 struct file_struct *file, STRUCT_STAT *st)
43 if (st->st_size != file->length) {
47 /* if always checksum is set then we use the checksum instead
48 of the file time to determine whether to sync */
49 if (always_checksum && S_ISREG(st->st_mode)) {
50 char sum[MD4_SUM_LENGTH];
51 file_checksum(fname,sum,st->st_size);
52 return (memcmp(sum,file->sum,csum_length) == 0);
59 return (st->st_mtime == file->modtime);
63 /* use a larger block size for really big files */
64 static int adapt_block_size(struct file_struct *file, int bsize)
68 if (bsize != BLOCK_SIZE) return bsize;
70 ret = file->length / (10000); /* rough heuristic */
71 ret = ret & ~15; /* multiple of 16 */
72 if (ret < bsize) ret = bsize;
73 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
79 send a sums struct down a fd
81 static void send_sums(struct sum_struct *s,int f_out)
85 /* tell the other guy how many we are going to be doing and how many
86 bytes there are in the last chunk */
87 write_int(f_out,s?s->count:0);
88 write_int(f_out,s?s->n:block_size);
89 write_int(f_out,s?s->remainder:0);
91 for (i=0;i<s->count;i++) {
92 write_int(f_out,s->sums[i].sum1);
93 write_buf(f_out,s->sums[i].sum2,csum_length);
99 generate a stream of signatures/checksums that describe a buffer
101 generate approximately one checksum every n bytes
103 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
106 struct sum_struct *s;
109 int remainder = (len%block_len);
112 count = (len+(block_len-1))/block_len;
114 s = (struct sum_struct *)malloc(sizeof(*s));
115 if (!s) out_of_memory("generate_sums");
118 s->remainder = remainder;
128 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
129 s->count,s->remainder,s->n,(int)s->flength);
131 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
132 if (!s->sums) out_of_memory("generate_sums");
134 for (i=0;i<count;i++) {
136 char *map = map_ptr(buf,offset,n1);
138 s->sums[i].sum1 = get_checksum1(map,n1);
139 get_checksum2(map,n1,s->sums[i].sum2);
141 s->sums[i].offset = offset;
146 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
147 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
157 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
161 struct map_struct *buf;
162 struct sum_struct *s;
164 struct file_struct *file = flist->files[i];
166 char fnamecmpbuf[MAXPATHLEN];
167 extern char *compare_dest;
168 extern int list_only;
170 if (list_only) return;
173 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
175 statret = link_stat(fname,&st);
177 if (S_ISDIR(file->mode)) {
179 if (statret == 0 && !S_ISDIR(st.st_mode)) {
180 if (do_unlink(fname) != 0) {
181 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
186 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
187 if (!(relative_paths && errno==ENOENT &&
188 create_directory_path(fname)==0 &&
189 do_mkdir(fname,file->mode)==0)) {
190 rprintf(FERROR,"mkdir %s : %s (2)\n",
191 fname,strerror(errno));
194 if (set_perms(fname,file,NULL,0) && verbose)
195 rprintf(FINFO,"%s/\n",fname);
199 if (preserve_links && S_ISLNK(file->mode)) {
201 char lnk[MAXPATHLEN];
203 extern int safe_symlinks;
205 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
207 rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
213 l = readlink(fname,lnk,MAXPATHLEN-1);
216 if (strcmp(lnk,file->link) == 0) {
217 set_perms(fname,file,&st,1);
223 if (do_symlink(file->link,fname) != 0) {
224 rprintf(FERROR,"link %s -> %s : %s\n",
225 fname,file->link,strerror(errno));
227 set_perms(fname,file,NULL,0);
229 rprintf(FINFO,"%s -> %s\n",
238 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
240 st.st_mode != file->mode ||
241 st.st_rdev != file->rdev) {
244 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
245 fname,(int)file->mode,(int)file->rdev);
246 if (do_mknod(fname,file->mode,file->rdev) != 0) {
247 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
249 set_perms(fname,file,NULL,0);
251 rprintf(FINFO,"%s\n",fname);
254 set_perms(fname,file,&st,1);
260 if (preserve_hard_links && check_hard_link(file)) {
262 rprintf(FINFO,"%s is a hard link\n",f_name(file));
266 if (!S_ISREG(file->mode)) {
267 rprintf(FINFO,"skipping non-regular file %s\n",fname);
273 if ((statret == -1) && (compare_dest != NULL)) {
274 /* try the file at compare_dest instead */
275 int saveerrno = errno;
276 slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
277 statret = link_stat(fnamecmpbuf,&st);
278 if (!S_ISREG(st.st_mode))
283 fnamecmp = fnamecmpbuf;
287 if (errno == ENOENT) {
289 if (!dry_run) send_sums(NULL,f_out);
292 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
297 if (!S_ISREG(st.st_mode)) {
298 if (delete_file(fname) != 0) {
302 /* now pretend the file didn't exist */
304 if (!dry_run) send_sums(NULL,f_out);
308 if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) {
310 rprintf(FINFO,"%s is newer\n",fname);
314 if (skip_file(fname, file, &st)) {
315 set_perms(fname,file,&st,1);
326 send_sums(NULL,f_out);
331 fd = open(fnamecmp,O_RDONLY);
334 rprintf(FERROR,"failed to open %s : %s\n",fnamecmp,strerror(errno));
335 rprintf(FERROR,"skipping %s\n",fname);
339 if (st.st_size > 0) {
340 buf = map_file(fd,st.st_size);
346 rprintf(FINFO,"gen mapped %s of size %d\n",fnamecmp,(int)st.st_size);
348 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
351 rprintf(FINFO,"sending sums for %d\n",i);
357 if (buf) unmap_file(buf);
364 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
370 rprintf(FINFO,"generator starting pid=%d count=%d\n",
371 (int)getpid(),flist->count);
373 for (i = 0; i < flist->count; i++) {
374 struct file_struct *file = flist->files[i];
375 mode_t saved_mode = file->mode;
376 if (!file->basename) continue;
378 /* we need to ensure that any directories we create have writeable
379 permissions initially so that we can create the files within
380 them. This is then fixed after the files are transferred */
381 if (!am_root && S_ISDIR(file->mode)) {
382 file->mode |= S_IWUSR; /* user write */
385 recv_generator(local_name?local_name:f_name(file),
388 file->mode = saved_mode;
392 csum_length = SUM_LENGTH;
396 rprintf(FINFO,"generate_files phase=%d\n",phase);
400 /* we expect to just sit around now, so don't exit on a
401 timeout. If we really get a timeout then the other process should
405 if (remote_version >= 13) {
406 /* in newer versions of the protocol the files can cycle through
407 the system more than once to catch initial checksum errors */
408 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
409 struct file_struct *file = flist->files[i];
410 recv_generator(local_name?local_name:f_name(file),
416 rprintf(FINFO,"generate_files phase=%d\n",phase);