[rsync/rsync.git] / sender.c

/*
   Copyright (C) Andrew Tridgell 1996
   Copyright (C) Paul Mackerras 1996

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "rsync.h"

extern int verbose;
extern int csum_length;
extern struct stats stats;
extern int io_error;
extern int dry_run;
extern int am_server;


/**
 * @file
 *
 * The sender gets checksums from the generator, calculates deltas,
 * and transmits them to the receiver.  The sender process runs on the
 * machine holding the source files.
 **/


void read_sum_head(int f, struct sum_struct *sum)
{
	extern int remote_version;

	sum->count = read_int(f);
	sum->blength = read_int(f);
	if (remote_version < 27)
	{
		sum->s2length = csum_length;
	} else {
		sum->s2length = read_int(f);
	}
	sum->remainder = read_int(f);
}

/**
 * Receive the checksums for a buffer
 **/
static struct sum_struct *receive_sums(int f)
{
	struct sum_struct *s;
	int i;
	OFF_T offset = 0;

	s = (struct sum_struct *)malloc(sizeof(*s));
	if (!s) out_of_memory("receive_sums");

	read_sum_head(f, s);

	s->sums = NULL;

	if (verbose > 3)
		rprintf(FINFO, "count=%ld n=%ld rem=%ld\n",
			(long) s->count, (long) s->blength,
			(long) s->remainder);

	if (s->count == 0)
		return(s);

	s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
	if (!s->sums) out_of_memory("receive_sums");

	for (i = 0; i < (int) s->count; i++) {
		s->sums[i].sum1 = read_int(f);
		read_buf(f, s->sums[i].sum2, s->s2length);

		s->sums[i].offset = offset;
		s->sums[i].i = i;

		if (i == (int) s->count-1 && s->remainder != 0) {
			s->sums[i].len = s->remainder;
		} else {
			s->sums[i].len = s->blength;
		}
		offset += s->sums[i].len;

		if (verbose > 3)
			rprintf(FINFO, "chunk[%d] len=%d offset=%.0f sum1=%08x\n",
				i, s->sums[i].len, (double)s->sums[i].offset, s->sums[i].sum1);
	}

	s->flength = offset;

	return s;
}


void send_files(struct file_list *flist, int f_out, int f_in)
{
	int fd = -1;
	struct sum_struct *s;
	struct map_struct *buf = NULL;
	STRUCT_STAT st;
	char fname[MAXPATHLEN];
	int i;
	struct file_struct *file;
	int phase = 0;
	extern struct stats stats;
	struct stats initial_stats;
	extern int write_batch;   /* dw */
	extern int read_batch;    /* dw */
	int checksums_match;   /* dw */
	int buff_len;  /* dw */
	char buff[CHUNK_SIZE];    /* dw */
	int j;   /* dw */
	int done;   /* dw */

	if (verbose > 2)
		rprintf(FINFO, "send_files starting\n");

	while (1) {
		int offset = 0;

		i = read_int(f_in);
		if (i == -1) {
			if (phase == 0) {
				phase++;
				csum_length = SUM_LENGTH;
				write_int(f_out, -1);
				if (verbose > 2)
					rprintf(FINFO, "send_files phase=%d\n", phase);
				continue;
			}
			break;
		}

		if (i < 0 || i >= flist->count) {
			rprintf(FERROR, "Invalid file index %d (count=%d)\n",
				i, flist->count);
			exit_cleanup(RERR_PROTOCOL);
		}

		file = flist->files[i];

		stats.num_transferred_files++;
		stats.total_transferred_size += file->length;

		fname[0] = 0;
		if (file->basedir) {
			strlcpy(fname, file->basedir, MAXPATHLEN);
			if (strlen(fname) == MAXPATHLEN-1) {
				io_error = 1;
				rprintf(FERROR, "send_files failed on long-named directory %s\n",
					fname);
				return;
			}
			strlcat(fname, "/", MAXPATHLEN);
			offset = strlen(file->basedir)+1;
		}
		strlcat(fname, f_name(file), MAXPATHLEN);

		if (verbose > 2)
			rprintf(FINFO, "send_files(%d, %s)\n", i, fname);

		if (dry_run) {
			if (!am_server && verbose) {	/* log transfer */
				rprintf(FINFO, "%s\n", fname+offset);
			}
			write_int(f_out, i);
			continue;
		}

		initial_stats = stats;

		s = receive_sums(f_in);
		if (!s) {
			io_error = 1;
			rprintf(FERROR, "receive_sums failed\n");
			return;
		}

		if (write_batch)
			write_batch_csum_info(&i, flist->count, s);

		if (!read_batch) {
			fd = do_open(fname, O_RDONLY, 0);
			if (fd == -1) {
				io_error = 1;
				rprintf(FERROR, "send_files failed to open %s: %s\n",
					fname, strerror(errno));
				free_sums(s);
				continue;
			}

			/* map the local file */
			if (do_fstat(fd, &st) != 0) {
				io_error = 1;
				rprintf(FERROR, "fstat failed : %s\n", strerror(errno));
				free_sums(s);
				close(fd);
				return;
			}

			if (st.st_size > 0) {
				buf = map_file(fd, st.st_size);
			} else {
				buf = NULL;
			}

			if (verbose > 2)
				rprintf(FINFO, "send_files mapped %s of size %.0f\n",
					fname, (double)st.st_size);

			write_int(f_out, i);

			if (write_batch)
				write_batch_delta_file((char *)&i, sizeof(i));

			write_sum_head(f_out, s);
		}

		if (verbose > 2 && !read_batch)
			rprintf(FINFO, "calling match_sums %s\n", fname);

		if (!am_server && verbose) {	/* log transfer */
			rprintf(FINFO, "%s\n", fname+offset);
		}

		set_compression(fname);

		if (read_batch) { /* dw */
			/* read checksums originally computed on sender side */
			read_batch_csum_info(i, s, &checksums_match);
			if (checksums_match) {
				read_batch_delta_file( (char *) &j, sizeof(int) );
				if (j != i) {    /* if flist index entries don't match*/
					rprintf(FINFO, "index mismatch in send_files\n");
					rprintf(FINFO, "read index = %d flist ndx = %d\n", j, i);
					close_batch_delta_file();
					close_batch_csums_file();
					exit_cleanup(1);
				} else {
					write_int(f_out, j);
					write_sum_head(f_out, s);
					done = 0;
					while (!done) {
						read_batch_delta_file( (char *) &buff_len, sizeof(int) );
						write_int(f_out, buff_len);
						if (buff_len == 0) {
							done = 1;
						} else {
							if (buff_len > 0) {
								read_batch_delta_file(buff, buff_len);
								write_buf(f_out, buff, buff_len);
							}
						}
					}  /* end while  */
					read_batch_delta_file( buff, MD4_SUM_LENGTH);
					write_buf(f_out, buff, MD4_SUM_LENGTH);

				}  /* j=i */
			} else {  /* not checksum match */
				rprintf (FINFO, "readbatch & checksums don't match\n");
				rprintf (FINFO, "filename=%s is being skipped\n", fname);
				continue;
			}
		} else  {
			match_sums(f_out, s, buf, st.st_size);
			log_send(file, &initial_stats);
		}

		if (!read_batch) { /* dw */
			if (buf) unmap_file(buf);
			close(fd);
		}

		free_sums(s);

		if (verbose > 2)
			rprintf(FINFO, "sender finished %s\n", fname);
	}

	if (verbose > 2)
		rprintf(FINFO, "send files finished\n");

	match_report();

	write_int(f_out, -1);
	if (write_batch || read_batch) { /* dw */
		close_batch_csums_file();
		close_batch_delta_file();
	}

}
Commit	Line	Data
e6e3f12f	1	/*
2f03f956 AT	2	Copyright (C) Andrew Tridgell 1996
2f03f956 AT	3	Copyright (C) Paul Mackerras 1996
e6e3f12f	4
2f03f956 AT	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.
e6e3f12f	9
2f03f956 AT	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.
e6e3f12f	14
2f03f956 AT	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;
2f03f956 AT	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
	29
0f9c48b1 MP	30	/**
	31	* @file
	32	*
	33	* The sender gets checksums from the generator, calculates deltas,
	34	* and transmits them to the receiver. The sender process runs on the
	35	* machine holding the source files.
	36	**/
	37
	38
fc0257c9 S	39	void read_sum_head(int f, struct sum_struct *sum)
	40	{
	41	extern int remote_version;
	42
	43	sum->count = read_int(f);
	44	sum->blength = read_int(f);
	45	if (remote_version < 27)
	46	{
	47	sum->s2length = csum_length;
	48	} else {
e6e3f12f	49	sum->s2length = read_int(f);
fc0257c9	50	}
e6e3f12f	51	sum->remainder = read_int(f);
fc0257c9 S	52	}
fc0257c9 S	53
ce8149b6 MP	54	/**
	55	* Receive the checksums for a buffer
	56	**/
2f03f956 AT	57	static struct sum_struct *receive_sums(int f)
	58	{
	59	struct sum_struct *s;
	60	int i;
	61	OFF_T offset = 0;
	62
	63	s = (struct sum_struct )malloc(sizeof(s));
	64	if (!s) out_of_memory("receive_sums");
	65
fc0257c9 S	66	read_sum_head(f, s);
fc0257c9 S	67
2f03f956 AT	68	s->sums = NULL;
	69
	70	if (verbose > 3)
e6e3f12f	71	rprintf(FINFO, "count=%ld n=%ld rem=%ld\n",
fc0257c9 S	72	(long) s->count, (long) s->blength,
fc0257c9 S	73	(long) s->remainder);
2f03f956	74
e6e3f12f	75	if (s->count == 0)
2f03f956 AT	76	return(s);
	77
	78	s->sums = (struct sum_buf )malloc(sizeof(s->sums[0])s->count);
	79	if (!s->sums) out_of_memory("receive_sums");
	80
e6e3f12f	81	for (i = 0; i < (int) s->count; i++) {
2f03f956	82	s->sums[i].sum1 = read_int(f);
e6e3f12f	83	read_buf(f, s->sums[i].sum2, s->s2length);
2f03f956 AT	84
	85	s->sums[i].offset = offset;
	86	s->sums[i].i = i;
	87
a261989c	88	if (i == (int) s->count-1 && s->remainder != 0) {
2f03f956 AT	89	s->sums[i].len = s->remainder;
2f03f956 AT	90	} else {
fc0257c9	91	s->sums[i].len = s->blength;
2f03f956 AT	92	}
	93	offset += s->sums[i].len;
	94
	95	if (verbose > 3)
e6e3f12f S	96	rprintf(FINFO, "chunk[%d] len=%d offset=%.0f sum1=%08x\n",
e6e3f12f S	97	i, s->sums[i].len, (double)s->sums[i].offset, s->sums[i].sum1);
2f03f956 AT	98	}
	99
	100	s->flength = offset;
	101
	102	return s;
	103	}
	104
	105
	106
e6e3f12f S	107	void send_files(struct file_list *flist, int f_out, int f_in)
e6e3f12f S	108	{
c1659c79	109	int fd = -1;
2f03f956	110	struct sum_struct *s;
c1659c79	111	struct map_struct *buf = NULL;
2f03f956	112	STRUCT_STAT st;
e6e3f12f	113	char fname[MAXPATHLEN];
2f03f956 AT	114	int i;
	115	struct file_struct *file;
	116	int phase = 0;
e6e3f12f	117	extern struct stats stats;
1b7c47cb	118	struct stats initial_stats;
6902ed17	119	extern int write_batch; /* dw */
6902ed17 MP	120	extern int read_batch; /* dw */
	121	int checksums_match; /* dw */
	122	int buff_len; /* dw */
	123	char buff[CHUNK_SIZE]; /* dw */
	124	int j; /* dw */
	125	int done; /* dw */
2f03f956 AT	126
2f03f956 AT	127	if (verbose > 2)
e6e3f12f	128	rprintf(FINFO, "send_files starting\n");
2f03f956	129
2f03f956	130	while (1) {
e6e3f12f	131	int offset = 0;
2f03f956 AT	132
	133	i = read_int(f_in);
	134	if (i == -1) {
e6e3f12f	135	if (phase == 0) {
2f03f956 AT	136	phase++;
2f03f956 AT	137	csum_length = SUM_LENGTH;
e6e3f12f	138	write_int(f_out, -1);
2f03f956	139	if (verbose > 2)
e6e3f12f	140	rprintf(FINFO, "send_files phase=%d\n", phase);
2f03f956 AT	141	continue;
	142	}
	143	break;
	144	}
	145
	146	if (i < 0 \|\| i >= flist->count) {
e6e3f12f	147	rprintf(FERROR, "Invalid file index %d (count=%d)\n",
2f03f956	148	i, flist->count);
65417579	149	exit_cleanup(RERR_PROTOCOL);
2f03f956 AT	150	}
	151
	152	file = flist->files[i];
	153
	154	stats.num_transferred_files++;
	155	stats.total_transferred_size += file->length;
	156
	157	fname[0] = 0;
	158	if (file->basedir) {
e6e3f12f	159	strlcpy(fname, file->basedir, MAXPATHLEN);
2f03f956 AT	160	if (strlen(fname) == MAXPATHLEN-1) {
	161	io_error = 1;
	162	rprintf(FERROR, "send_files failed on long-named directory %s\n",
	163	fname);
	164	return;
	165	}
e6e3f12f	166	strlcat(fname, "/", MAXPATHLEN);
2f03f956 AT	167	offset = strlen(file->basedir)+1;
2f03f956 AT	168	}
e6e3f12f S	169	strlcat(fname, f_name(file), MAXPATHLEN);
	170
	171	if (verbose > 2)
	172	rprintf(FINFO, "send_files(%d, %s)\n", i, fname);
	173
	174	if (dry_run) {
42d4edc0 S	175	if (!am_server && verbose) { /* log transfer */
42d4edc0 S	176	rprintf(FINFO, "%s\n", fname+offset);
11a5a3c7	177	}
e6e3f12f	178	write_int(f_out, i);
2f03f956 AT	179	continue;
	180	}
	181
1b7c47cb AT	182	initial_stats = stats;
1b7c47cb AT	183
2f03f956 AT	184	s = receive_sums(f_in);
	185	if (!s) {
	186	io_error = 1;
e6e3f12f	187	rprintf(FERROR, "receive_sums failed\n");
2f03f956 AT	188	return;
2f03f956 AT	189	}
76f79ba7 MP	190
76f79ba7 MP	191	if (write_batch)
e6e3f12f S	192	write_batch_csum_info(&i, flist->count, s);
e6e3f12f S	193
6902ed17	194	if (!read_batch) {
c1659c79 MP	195	fd = do_open(fname, O_RDONLY, 0);
	196	if (fd == -1) {
	197	io_error = 1;
e6e3f12f S	198	rprintf(FERROR, "send_files failed to open %s: %s\n",
e6e3f12f S	199	fname, strerror(errno));
c1659c79 MP	200	free_sums(s);
	201	continue;
	202	}
e6e3f12f	203
c1659c79	204	/* map the local file */
e6e3f12f	205	if (do_fstat(fd, &st) != 0) {
c1659c79	206	io_error = 1;
e6e3f12f	207	rprintf(FERROR, "fstat failed : %s\n", strerror(errno));
c1659c79 MP	208	free_sums(s);
	209	close(fd);
	210	return;
	211	}
e6e3f12f	212
c1659c79	213	if (st.st_size > 0) {
e6e3f12f	214	buf = map_file(fd, st.st_size);
c1659c79 MP	215	} else {
	216	buf = NULL;
	217	}
e6e3f12f	218
c1659c79	219	if (verbose > 2)
e6e3f12f S	220	rprintf(FINFO, "send_files mapped %s of size %.0f\n",
	221	fname, (double)st.st_size);
	222
	223	write_int(f_out, i);
11a5a3c7	224
c1659c79	225	if (write_batch)
e6e3f12f	226	write_batch_delta_file((char *)&i, sizeof(i));
6902ed17	227
fc0257c9	228	write_sum_head(f_out, s);
6902ed17	229	}
e6e3f12f S	230
	231	if (verbose > 2 && !read_batch)
	232	rprintf(FINFO, "calling match_sums %s\n", fname);
	233
42d4edc0 S	234	if (!am_server && verbose) { /* log transfer */
42d4edc0 S	235	rprintf(FINFO, "%s\n", fname+offset);
11a5a3c7	236	}
83fff1aa AT	237
83fff1aa AT	238	set_compression(fname);
1b7c47cb	239
e6e3f12f S	240	if (read_batch) { /* dw */
	241	/* read checksums originally computed on sender side */
	242	read_batch_csum_info(i, s, &checksums_match);
	243	if (checksums_match) {
	244	read_batch_delta_file( (char *) &j, sizeof(int) );
	245	if (j != i) { /* if flist index entries don't match*/
	246	rprintf(FINFO, "index mismatch in send_files\n");
	247	rprintf(FINFO, "read index = %d flist ndx = %d\n", j, i);
	248	close_batch_delta_file();
	249	close_batch_csums_file();
	250	exit_cleanup(1);
	251	} else {
	252	write_int(f_out, j);
	253	write_sum_head(f_out, s);
	254	done = 0;
	255	while (!done) {
	256	read_batch_delta_file( (char *) &buff_len, sizeof(int) );
	257	write_int(f_out, buff_len);
	258	if (buff_len == 0) {
	259	done = 1;
	260	} else {
	261	if (buff_len > 0) {
	262	read_batch_delta_file(buff, buff_len);
	263	write_buf(f_out, buff, buff_len);
	264	}
	265	}
	266	} /* end while */
	267	read_batch_delta_file( buff, MD4_SUM_LENGTH);
	268	write_buf(f_out, buff, MD4_SUM_LENGTH);
	269
	270	} /* j=i */
	271	} else { /* not checksum match */
	272	rprintf (FINFO, "readbatch & checksums don't match\n");
	273	rprintf (FINFO, "filename=%s is being skipped\n", fname);
	274	continue;
	275	}
	276	} else {
	277	match_sums(f_out, s, buf, st.st_size);
	278	log_send(file, &initial_stats);
	279	}
6902ed17 MP	280
6902ed17 MP	281	if (!read_batch) { /* dw */
e6e3f12f S	282	if (buf) unmap_file(buf);
e6e3f12f S	283	close(fd);
6902ed17	284	}
e6e3f12f	285
2f03f956	286	free_sums(s);
e6e3f12f	287
2f03f956	288	if (verbose > 2)
e6e3f12f	289	rprintf(FINFO, "sender finished %s\n", fname);
2f03f956 AT	290	}
	291
	292	if (verbose > 2)
e6e3f12f	293	rprintf(FINFO, "send files finished\n");
2f03f956 AT	294
	295	match_report();
	296
e6e3f12f	297	write_int(f_out, -1);
6902ed17	298	if (write_batch \|\| read_batch) { /* dw */
e6e3f12f S	299	close_batch_csums_file();
e6e3f12f S	300	close_batch_delta_file();
6902ed17 MP	301	}
6902ed17 MP	302
2f03f956 AT	303	}
	304
	305
	306
	307
	308