Tweaked an error message.
[rsync/rsync.git] / receiver.c
CommitLineData
e327acec
MP
1/* -*- c-file-style: "linux" -*-
2
3 Copyright (C) 1996-2000 by Andrew Tridgell
2f03f956
AT
4 Copyright (C) Paul Mackerras 1996
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#include "rsync.h"
22
23extern int verbose;
24extern int recurse;
25extern int delete_mode;
d04e9c51 26extern int protocol_version;
2f03f956
AT
27extern int csum_length;
28extern struct stats stats;
29extern int dry_run;
30extern int am_server;
31extern int relative_paths;
32extern int preserve_hard_links;
33extern int cvs_exclude;
34extern int io_error;
35extern char *tmpdir;
375a4556 36extern char *compare_dest;
53dd3135 37extern int make_backups;
16417f8b 38extern int do_progress;
d74a2e3e 39extern char *backup_dir;
53dd3135 40extern char *backup_suffix;
d74a2e3e 41extern int backup_suffix_len;
2f03f956 42
2f03f956 43static struct delete_list {
6abd193f
MP
44 DEV64_T dev;
45 INO64_T inode;
2f03f956
AT
46} *delete_list;
47static int dlist_len, dlist_alloc_len;
48
2f03f956
AT
49/* yuck! This function wouldn't have been necessary if I had the sorting
50 algorithm right. Unfortunately fixing the sorting algorithm would introduce
51 a backward incompatibility as file list indexes are sent over the link.
52*/
53static int delete_already_done(struct file_list *flist,int j)
54{
55 int i;
56 STRUCT_STAT st;
57
58 if (link_stat(f_name(flist->files[j]), &st)) return 1;
59
60 for (i=0;i<dlist_len;i++) {
61 if (st.st_ino == delete_list[i].inode &&
d01350a8 62 (DEV64_T)st.st_dev == delete_list[i].dev)
2f03f956
AT
63 return 1;
64 }
65
66 return 0;
67}
68
69static void add_delete_entry(struct file_struct *file)
70{
71 if (dlist_len == dlist_alloc_len) {
72 dlist_alloc_len += 1024;
73 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
74 if (!delete_list) out_of_memory("add_delete_entry");
75 }
76
77 delete_list[dlist_len].dev = file->dev;
78 delete_list[dlist_len].inode = file->inode;
79 dlist_len++;
80
81 if (verbose > 3)
82 rprintf(FINFO,"added %s to delete list\n", f_name(file));
83}
84
d74a2e3e 85static void delete_one(char *fn, int is_dir)
2f03f956 86{
d74a2e3e
WD
87 if (!is_dir) {
88 if (robust_unlink(fn) != 0) {
89 rprintf(FERROR, "delete_one: unlink %s: %s\n",
90 fn, strerror(errno));
2f03f956 91 } else if (verbose) {
d74a2e3e 92 rprintf(FINFO, "deleting %s\n", fn);
2f03f956
AT
93 }
94 } else {
d74a2e3e
WD
95 if (do_rmdir(fn) != 0) {
96 if (errno != ENOTEMPTY && errno != EEXIST) {
97 rprintf(FERROR, "delete_one: rmdir %s: %s\n",
98 fn, strerror(errno));
99 }
2f03f956 100 } else if (verbose) {
d74a2e3e 101 rprintf(FINFO, "deleting directory %s\n", fn);
2f03f956
AT
102 }
103 }
104}
105
106
d74a2e3e
WD
107static int is_backup_file(char *fn)
108{
109 int k = strlen(fn) - backup_suffix_len;
110 return k > 0 && strcmp(fn+k, backup_suffix) == 0;
111}
2f03f956
AT
112
113
114/* this deletes any files on the receiving side that are not present
115 on the sending side. For version 1.6.4 I have changed the behaviour
116 to match more closely what most people seem to expect of this option */
6957ae33 117void delete_files(struct file_list *flist)
2f03f956
AT
118{
119 struct file_list *local_file_list;
120 int i, j;
121 char *name;
cda2ae84 122 extern int module_id;
ef55c686 123 extern int ignore_errors;
0b73ca12
AT
124 extern int max_delete;
125 static int deletion_count;
2f03f956
AT
126
127 if (cvs_exclude)
128 add_cvs_excludes();
129
ef55c686 130 if (io_error && !(lp_ignore_errors(module_id) || ignore_errors)) {
2f03f956
AT
131 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
132 return;
133 }
134
135 for (j=0;j<flist->count;j++) {
136 if (!S_ISDIR(flist->files[j]->mode) ||
137 !(flist->files[j]->flags & FLAG_DELETE)) continue;
138
d04e9c51 139 if (protocol_version < 19 &&
2f03f956
AT
140 delete_already_done(flist, j)) continue;
141
142 name = strdup(f_name(flist->files[j]));
143
144 if (!(local_file_list = send_file_list(-1,1,&name))) {
145 free(name);
146 continue;
147 }
148
149 if (verbose > 1)
150 rprintf(FINFO,"deleting in %s\n", name);
151
152 for (i=local_file_list->count-1;i>=0;i--) {
0b73ca12 153 if (max_delete && deletion_count > max_delete) break;
2f03f956 154 if (!local_file_list->files[i]->basename) continue;
d04e9c51 155 if (protocol_version < 19 &&
2f03f956
AT
156 S_ISDIR(local_file_list->files[i]->mode))
157 add_delete_entry(local_file_list->files[i]);
158 if (-1 == flist_find(flist,local_file_list->files[i])) {
53dd3135 159 char *f = f_name(local_file_list->files[i]);
d74a2e3e 160 if (make_backups && (backup_dir || !is_backup_file(f))) {
53dd3135 161 (void) make_backup(f);
d74a2e3e
WD
162 if (verbose)
163 rprintf(FINFO, "deleting %s\n", f);
53dd3135 164 } else {
d74a2e3e
WD
165 int mode = local_file_list->files[i]->mode;
166 delete_one(f, S_ISDIR(mode) != 0);
53dd3135 167 }
31f3b68a 168 deletion_count++;
53dd3135 169 }
2f03f956
AT
170 }
171 flist_free(local_file_list);
172 free(name);
173 }
174}
175
176
52d3e106
S
177/*
178 * get_tmpname() - create a tmp filename for a given filename
179 *
180 * If a tmpdir is defined, use that as the directory to
181 * put it in. Otherwise, the tmp filename is in the same
182 * directory as the given name. Note that there may be no
183 * directory at all in the given name!
184 *
185 * The tmp filename is basically the given filename with a
186 * dot prepended, and .XXXXXX appended (for mkstemp() to
187 * put its unique gunk in). Take care to not exceed
188 * either the MAXPATHLEN or NAME_MAX, esp. the last, as
189 * the basename basically becomes 8 chars longer. In that
190 * case, the original name is shortened sufficiently to
191 * make it all fit.
192 *
193 * Of course, there's no real reason for the tmp name to
194 * look like the original, except to satisfy us humans.
195 * As long as it's unique, rsync will work.
196 */
197
2f03f956
AT
198static int get_tmpname(char *fnametmp, char *fname)
199{
200 char *f;
52d3e106
S
201 int length = 0;
202 int maxname;
2f03f956 203
2f03f956 204 if (tmpdir) {
52d3e106
S
205 strlcpy(fnametmp, tmpdir, MAXPATHLEN - 2);
206 length = strlen(fnametmp);
207 fnametmp[length++] = '/';
208 fnametmp[length] = '\0'; /* always NULL terminated */
0c2ef5f4 209 }
52d3e106 210
0c2ef5f4 211 if ((f = strrchr(fname, '/')) != NULL) {
52d3e106
S
212 ++f;
213 if (!tmpdir) {
214 length = f - fname;
0c2ef5f4 215 /* copy up to and including the slash */
52d3e106 216 strlcpy(fnametmp, fname, length + 1);
0c2ef5f4 217 }
52d3e106
S
218 } else {
219 f = fname;
2f03f956 220 }
52d3e106
S
221 fnametmp[length++] = '.';
222 fnametmp[length] = '\0'; /* always NULL terminated */
2f03f956 223
52d3e106 224 maxname = MIN(MAXPATHLEN - 7 - length, NAME_MAX - 8);
2f03f956 225
0c2ef5f4 226 if (maxname < 1) {
52d3e106
S
227 rprintf(FERROR, "temporary filename too long: %s\n", fname);
228 fnametmp[0] = '\0';
2f03f956
AT
229 return 0;
230 }
231
52d3e106
S
232 strlcpy(fnametmp + length, f, maxname);
233 strcat(fnametmp + length, ".XXXXXX");
2f03f956
AT
234
235 return 1;
236}
237
238
239static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname,
240 OFF_T total_size)
241{
9dd891bb 242 int i;
fc0257c9
S
243 struct sum_struct sum;
244 unsigned int len;
2f03f956
AT
245 OFF_T offset = 0;
246 OFF_T offset2;
247 char *data;
248 static char file_sum1[MD4_SUM_LENGTH];
249 static char file_sum2[MD4_SUM_LENGTH];
250 char *map=NULL;
251
fc0257c9 252 read_sum_head(f_in, &sum);
2f03f956
AT
253
254 sum_init();
255
256 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
16417f8b
WD
257 if (do_progress)
258 show_progress(offset, total_size);
2f03f956
AT
259
260 if (i > 0) {
261 extern int cleanup_got_literal;
262
263 if (verbose > 3) {
5f808dfb
AT
264 rprintf(FINFO,"data recv %d at %.0f\n",
265 i,(double)offset);
2f03f956
AT
266 }
267
268 stats.literal_data += i;
269 cleanup_got_literal = 1;
270
271 sum_update(data,i);
272
273 if (fd != -1 && write_file(fd,data,i) != i) {
274 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
65417579 275 exit_cleanup(RERR_FILEIO);
2f03f956
AT
276 }
277 offset += i;
278 continue;
279 }
280
281 i = -(i+1);
fc0257c9
S
282 offset2 = i*(OFF_T)sum.blength;
283 len = sum.blength;
284 if (i == (int) sum.count-1 && sum.remainder != 0)
285 len = sum.remainder;
2f03f956
AT
286
287 stats.matched_data += len;
288
289 if (verbose > 3)
5f808dfb
AT
290 rprintf(FINFO,"chunk[%d] of size %d at %.0f offset=%.0f\n",
291 i,len,(double)offset2,(double)offset);
2f03f956 292
c55f7021
AT
293 if (buf) {
294 map = map_ptr(buf,offset2,len);
2f03f956 295
c55f7021
AT
296 see_token(map, len);
297 sum_update(map,len);
298 }
2f03f956 299
a261989c 300 if (fd != -1 && write_file(fd,map,len) != (int) len) {
2f03f956
AT
301 rprintf(FERROR,"write failed on %s : %s\n",
302 fname,strerror(errno));
65417579 303 exit_cleanup(RERR_FILEIO);
2f03f956
AT
304 }
305 offset += len;
306 }
307
16417f8b
WD
308 if (do_progress)
309 end_progress(total_size);
2f03f956
AT
310
311 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
312 rprintf(FERROR,"write failed on %s : %s\n",
313 fname,strerror(errno));
65417579 314 exit_cleanup(RERR_FILEIO);
2f03f956
AT
315 }
316
317 sum_end(file_sum1);
318
bc63ae3f
S
319 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
320 if (verbose > 2) {
321 rprintf(FINFO,"got file_sum\n");
322 }
323 if (fd != -1
324 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
325 return 0;
2f03f956
AT
326 }
327 return 1;
328}
329
330
b35d0d8e
MP
331/**
332 * main routine for receiver process.
333 *
334 * Receiver process runs on the same host as the generator process. */
2f03f956
AT
335int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
336{
337 int fd1,fd2;
338 STRUCT_STAT st;
339 char *fname;
f62c17e3 340 char template[MAXPATHLEN];
2f03f956 341 char fnametmp[MAXPATHLEN];
375a4556
DD
342 char *fnamecmp;
343 char fnamecmpbuf[MAXPATHLEN];
2f03f956
AT
344 struct map_struct *buf;
345 int i;
346 struct file_struct *file;
347 int phase=0;
348 int recv_ok;
1b7c47cb 349 extern struct stats stats;
4df9f368 350 extern int preserve_perms;
57df171b 351 extern int delete_after;
b35d0d8e 352 extern int orig_umask;
1b7c47cb 353 struct stats initial_stats;
11a5a3c7 354
2f03f956
AT
355 if (verbose > 2) {
356 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
357 }
358
2f03f956
AT
359 while (1) {
360 cleanup_disable();
361
362 i = read_int(f_in);
363 if (i == -1) {
bc63ae3f 364 if (phase==0) {
2f03f956
AT
365 phase++;
366 csum_length = SUM_LENGTH;
367 if (verbose > 2)
368 rprintf(FINFO,"recv_files phase=%d\n",phase);
369 write_int(f_gen,-1);
370 continue;
371 }
372 break;
373 }
374
375 if (i < 0 || i >= flist->count) {
376 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
377 i, flist->count);
65417579 378 exit_cleanup(RERR_PROTOCOL);
2f03f956
AT
379 }
380
381 file = flist->files[i];
382 fname = f_name(file);
383
384 stats.num_transferred_files++;
385 stats.total_transferred_size += file->length;
386
387 if (local_name)
388 fname = local_name;
389
390 if (dry_run) {
42d4edc0
S
391 if (!am_server && verbose) { /* log transfer */
392 rprintf(FINFO, "%s\n", fname);
11a5a3c7 393 }
2f03f956
AT
394 continue;
395 }
396
1b7c47cb
AT
397 initial_stats = stats;
398
2f03f956
AT
399 if (verbose > 2)
400 rprintf(FINFO,"recv_files(%s)\n",fname);
401
375a4556
DD
402 fnamecmp = fname;
403
2f03f956 404 /* open the file */
8c9fd200 405 fd1 = do_open(fnamecmp, O_RDONLY, 0);
375a4556
DD
406
407 if ((fd1 == -1) && (compare_dest != NULL)) {
408 /* try the file at compare_dest instead */
8950ac03 409 snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",
375a4556
DD
410 compare_dest,fname);
411 fnamecmp = fnamecmpbuf;
8c9fd200 412 fd1 = do_open(fnamecmp, O_RDONLY, 0);
375a4556 413 }
2f03f956
AT
414
415 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
375a4556 416 rprintf(FERROR,"fstat %s : %s\n",fnamecmp,strerror(errno));
2f03f956
AT
417 receive_data(f_in,NULL,-1,NULL,file->length);
418 close(fd1);
419 continue;
420 }
421
350e4e4d
S
422 if (fd1 != -1 && S_ISDIR(st.st_mode) && fnamecmp == fname) {
423 /* this special handling for directories
424 * wouldn't be necessary if robust_rename()
425 * and the underlying robust_unlink could cope
426 * with directories
427 */
428 rprintf(FERROR,"%s : is a directory (recv_files)\n",
429 fnamecmp);
430 receive_data(f_in, NULL, -1, NULL, file->length);
2f03f956
AT
431 close(fd1);
432 continue;
433 }
434
350e4e4d
S
435 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
436 close(fd1);
437 fd1 = -1;
438 buf = NULL;
439 }
440
4df9f368 441 if (fd1 != -1 && !preserve_perms) {
85ed0aa3
S
442 /* if the file exists already and we aren't preserving
443 permissions then act as though the remote end sent
4df9f368
AT
444 us the file permissions we already have */
445 file->mode = st.st_mode;
446 }
447
2f03f956
AT
448 if (fd1 != -1 && st.st_size > 0) {
449 buf = map_file(fd1,st.st_size);
450 if (verbose > 2)
5f808dfb 451 rprintf(FINFO,"recv mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
2f03f956
AT
452 } else {
453 buf = NULL;
454 }
455
456 if (!get_tmpname(fnametmp,fname)) {
457 if (buf) unmap_file(buf);
458 if (fd1 != -1) close(fd1);
459 continue;
460 }
461
f62c17e3 462 strlcpy(template, fnametmp, sizeof(template));
2f03f956
AT
463
464 /* we initially set the perms without the
465 setuid/setgid bits to ensure that there is no race
466 condition. They are then correctly updated after
467 the lchown. Thanks to snabb@epipe.fi for pointing
972a3619
DD
468 this out. We also set it initially without group
469 access because of a similar race condition. */
f62c17e3 470 fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
2f03f956 471
752eaba4
DD
472 /* in most cases parent directories will already exist
473 because their information should have been previously
474 transferred, but that may not be the case with -R */
475 if (fd2 == -1 && relative_paths && errno == ENOENT &&
b35d0d8e 476 create_directory_path(fnametmp, orig_umask) == 0) {
f62c17e3
AT
477 strlcpy(fnametmp, template, sizeof(fnametmp));
478 fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
2f03f956
AT
479 }
480 if (fd2 == -1) {
0c2ef5f4
WD
481 extern char curr_dir[];
482 char *p1, *p2;
483 if (*fnametmp == '.') {
484 p1 = curr_dir;
485 p2 = "/";
486 } else
487 p1 = p2 = "";
488 rprintf(FERROR, "mkstemp %s%s%s failed: %s\n",
489 p1, p2, fnametmp, strerror(errno));
2f03f956
AT
490 receive_data(f_in,buf,-1,NULL,file->length);
491 if (buf) unmap_file(buf);
492 if (fd1 != -1) close(fd1);
493 continue;
494 }
495
c6b81a98 496 cleanup_set(fnametmp, fname, file, buf, fd1, fd2);
2f03f956 497
42d4edc0
S
498 if (!am_server && verbose) { /* log transfer */
499 rprintf(FINFO, "%s\n", fname);
11a5a3c7
AT
500 }
501
2f03f956
AT
502 /* recv file data */
503 recv_ok = receive_data(f_in,buf,fd2,fname,file->length);
1b7c47cb
AT
504
505 log_recv(file, &initial_stats);
2f03f956
AT
506
507 if (buf) unmap_file(buf);
508 if (fd1 != -1) {
509 close(fd1);
510 }
511 close(fd2);
512
513 if (verbose > 2)
514 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
515
516 finish_transfer(fname, fnametmp, file);
c6b81a98 517
2f03f956 518 cleanup_disable();
554e0a8d 519
2f03f956
AT
520 if (!recv_ok) {
521 if (csum_length == SUM_LENGTH) {
522 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
523 fname);
524 } else {
525 if (verbose > 1)
526 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
527 write_int(f_gen,i);
528 }
529 }
530 }
531
57df171b
AT
532 if (delete_after) {
533 if (recurse && delete_mode && !local_name && flist->count>0) {
534 delete_files(flist);
535 }
536 }
537
2f03f956 538 if (preserve_hard_links)
fae5bb31 539 do_hard_links();
2f03f956
AT
540
541 /* now we need to fix any directory permissions that were
542 modified during the transfer */
543 for (i = 0; i < flist->count; i++) {
544 file = flist->files[i];
545 if (!file->basename || !S_ISDIR(file->mode)) continue;
e78733d9 546 recv_generator(local_name?local_name:f_name(file),flist,i,-1);
2f03f956
AT
547 }
548
549 if (verbose > 2)
550 rprintf(FINFO,"recv_files finished\n");
551
552 return 0;
553}
554