211aec25feccfa2282b6c0f6776dd90292810781
[rsync.git] / sender.c
1 /*
2    Copyright (C) Andrew Tridgell 1996
3    Copyright (C) Paul Mackerras 1996
4
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.
9
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.
14
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.
18 */
19
20 #include "rsync.h"
21
22 extern int verbose;
23 extern int csum_length;
24 extern struct stats stats;
25 extern int io_error;
26 extern int dry_run;
27 extern int am_server;
28 extern int am_daemon;
29 extern int protocol_version;
30 extern struct stats stats;
31
32
33 /**
34  * @file
35  *
36  * The sender gets checksums from the generator, calculates deltas,
37  * and transmits them to the receiver.  The sender process runs on the
38  * machine holding the source files.
39  **/
40 void read_sum_head(int f, struct sum_struct *sum)
41 {
42         sum->count = read_int(f);
43         sum->blength = read_int(f);
44         if (protocol_version < 27) {
45                 sum->s2length = csum_length;
46         } else {
47                 sum->s2length = read_int(f);
48                 if (sum->s2length > MD4_SUM_LENGTH) {
49                         rprintf(FERROR, "Invalid checksum length %ld\n",
50                             (long)sum->s2length);
51                         exit_cleanup(RERR_PROTOCOL);
52                 }
53         }
54         sum->remainder = read_int(f);
55 }
56
57 /**
58  * Receive the checksums for a buffer
59  **/
60 static struct sum_struct *receive_sums(int f)
61 {
62         struct sum_struct *s;
63         int i;
64         OFF_T offset = 0;
65
66         if (!(s = new(struct sum_struct)))
67                 out_of_memory("receive_sums");
68
69         read_sum_head(f, s);
70
71         s->sums = NULL;
72
73         if (verbose > 3) {
74                 rprintf(FINFO, "count=%ld n=%u rem=%u\n",
75                         (long)s->count, s->blength, s->remainder);
76         }
77
78         if (s->count == 0)
79                 return(s);
80
81         if (!(s->sums = new_array(struct sum_buf, s->count)))
82                 out_of_memory("receive_sums");
83
84         for (i = 0; i < (int)s->count; i++) {
85                 s->sums[i].sum1 = read_int(f);
86                 read_buf(f, s->sums[i].sum2, s->s2length);
87
88                 s->sums[i].offset = offset;
89                 s->sums[i].flags = 0;
90
91                 if (i == (int)s->count-1 && s->remainder != 0)
92                         s->sums[i].len = s->remainder;
93                 else
94                         s->sums[i].len = s->blength;
95                 offset += s->sums[i].len;
96
97                 if (verbose > 3) {
98                         rprintf(FINFO,
99                                 "chunk[%d] len=%d offset=%.0f sum1=%08x\n",
100                                 i, s->sums[i].len, (double)s->sums[i].offset,
101                                 s->sums[i].sum1);
102                 }
103         }
104
105         s->flength = offset;
106
107         return s;
108 }
109
110
111
112 void send_files(struct file_list *flist, int f_out, int f_in)
113 {
114         int fd = -1;
115         struct sum_struct *s;
116         struct map_struct *mbuf = NULL;
117         STRUCT_STAT st;
118         char fname[MAXPATHLEN];
119         int i;
120         struct file_struct *file;
121         int phase = 0;
122         struct stats initial_stats;
123         int j;
124
125         if (verbose > 2)
126                 rprintf(FINFO, "send_files starting\n");
127
128         while (1) {
129                 unsigned int offset;
130
131                 i = read_int(f_in);
132                 if (i == -1) {
133                         if (phase == 0) {
134                                 phase++;
135                                 csum_length = SUM_LENGTH;
136                                 write_int(f_out, -1);
137                                 if (verbose > 2)
138                                         rprintf(FINFO, "send_files phase=%d\n", phase);
139                                 continue;
140                         }
141                         break;
142                 }
143
144                 if (i < 0 || i >= flist->count) {
145                         rprintf(FERROR, "Invalid file index %d (count=%d)\n",
146                                 i, flist->count);
147                         exit_cleanup(RERR_PROTOCOL);
148                 }
149
150                 file = flist->files[i];
151
152                 stats.current_file_index = i;
153                 stats.num_transferred_files++;
154                 stats.total_transferred_size += file->length;
155
156                 if (file->basedir) {
157                         /* N.B. We're sure that this fits, so offset is OK. */
158                         offset = strlcpy(fname, file->basedir, sizeof fname);
159                         if (!offset || fname[offset-1] != '/')
160                                 fname[offset++] = '/';
161                 } else
162                         offset = 0;
163                 f_name_to(file, fname + offset);
164
165                 if (verbose > 2)
166                         rprintf(FINFO, "send_files(%d, %s)\n", i, fname);
167
168                 if (dry_run) {
169                         if (!am_server && verbose) {
170                                 rprintf(FINFO, "%s\n", fname+offset);
171                         }
172                         write_int(f_out, i);
173                         continue;
174                 }
175
176                 initial_stats = stats;
177
178                 if (!(s = receive_sums(f_in))) {
179                         io_error |= IOERR_GENERAL;
180                         rprintf(FERROR, "receive_sums failed\n");
181                         return;
182                 }
183
184                 fd = do_open(fname, O_RDONLY, 0);
185                 if (fd == -1) {
186                         if (errno == ENOENT) {
187                                 enum logcode c = am_daemon
188                                     && protocol_version < 28 ? FERROR
189                                                              : FINFO;
190                                 io_error |= IOERR_VANISHED;
191                                 rprintf(c, "file has vanished: %s\n",
192                                         full_fname(fname));
193                         } else {
194                                 io_error |= IOERR_GENERAL;
195                                 rsyserr(FERROR, errno,
196                                         "send_files failed to open %s",
197                                         full_fname(fname));
198                         }
199                         free_sums(s);
200                         continue;
201                 }
202
203                 /* map the local file */
204                 if (do_fstat(fd, &st) != 0) {
205                         io_error |= IOERR_GENERAL;
206                         rsyserr(FERROR, errno, "fstat failed");
207                         free_sums(s);
208                         close(fd);
209                         return;
210                 }
211
212                 mbuf = st.st_size ? map_file(fd, st.st_size, s->blength) : NULL;
213
214                 if (verbose > 2) {
215                         rprintf(FINFO, "send_files mapped %s of size %.0f\n",
216                                 fname, (double)st.st_size);
217                 }
218
219                 write_int(f_out, i);
220                 write_sum_head(f_out, s);
221
222                 if (verbose > 2)
223                         rprintf(FINFO, "calling match_sums %s\n", fname);
224
225                 if (!am_server && verbose) {
226                         rprintf(FINFO, "%s\n", fname+offset);
227                 }
228
229                 set_compression(fname);
230
231                 match_sums(f_out, s, mbuf, st.st_size);
232                 log_send(file, &initial_stats);
233
234                 if (mbuf) {
235                         j = unmap_file(mbuf);
236                         if (j) {
237                                 io_error |= IOERR_GENERAL;
238                                 rsyserr(FERROR, j,
239                                         "read errors mapping %s",
240                                         full_fname(fname));
241                         }
242                 }
243                 close(fd);
244
245                 free_sums(s);
246
247                 if (verbose > 2)
248                         rprintf(FINFO, "sender finished %s\n", fname);
249         }
250
251         if (verbose > 2)
252                 rprintf(FINFO, "send files finished\n");
253
254         match_report();
255
256         write_int(f_out, -1);
257 }