[rsync/rsync.git] / main.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"

time_t starttime = 0;

struct stats stats;

extern int csum_length;

extern int verbose;

static void report(int f)
{
	time_t t = time(NULL);
	extern int am_server;
	extern int am_sender;
	extern int am_daemon;
	extern int do_stats;

	if (am_daemon) {
		syslog(LOG_INFO,"wrote %.0f bytes  read %.0f bytes  total size %.0f\n",
		       (double)stats.total_written,
		       (double)stats.total_read,
		       (double)stats.total_size);
		if (f == -1 || !am_sender) return;
	}

	if (!verbose) return;

	if (am_server && !am_sender) return;

	if (am_server && am_sender) {
		write_longint(f,stats.total_read);
		write_longint(f,stats.total_written);
		write_longint(f,stats.total_size);
		return;
	}
    
	if (!am_sender) {
		int64 r;
		stats.total_written = read_longint(f);
		r = read_longint(f);
		stats.total_size = read_longint(f);
		stats.total_read = r;
	}

	if (do_stats) {
		printf("\nNumber of files: %d\n", stats.num_files);
		printf("Number of files transferred: %d\n", 
		       stats.num_transferred_files);
		printf("Total file size: %.0f bytes\n", 
		       (double)stats.total_size);
		printf("Total transferred file size: %.0f bytes\n", 
		       (double)stats.total_transferred_size);
		printf("Literal data: %.0f bytes\n", 
		       (double)stats.literal_data);
		printf("Matched data: %.0f bytes\n", 
		       (double)stats.matched_data);
		printf("File list size: %d\n", stats.flist_size);
		printf("Total bytes written: %.0f\n", 
		       (double)stats.total_written);
		printf("Total bytes read: %.0f\n\n", 
		       (double)stats.total_read);
	}
	
	printf("wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
	       (double)stats.total_written,
	       (double)stats.total_read,
	       (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
	printf("total size is %.0f  speedup is %.2f\n",
	       (double)stats.total_size,
	       (1.0*stats.total_size)/(stats.total_written+stats.total_read));
}


static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
{
	char *args[100];
	int i,argc=0, ret;
	char *tok,*dir=NULL;
	extern int local_server;
	extern char *rsync_path;

	if (!local_server) {
		if (!cmd)
			cmd = getenv(RSYNC_RSH_ENV);
		if (!cmd)
			cmd = RSYNC_RSH;
		cmd = strdup(cmd);
		if (!cmd) 
			goto oom;

		for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
			args[argc++] = tok;
		}

#if HAVE_REMSH
		/* remsh (on HPUX) takes the arguments the other way around */
		args[argc++] = machine;
		if (user) {
			args[argc++] = "-l";
			args[argc++] = user;
		}
#else
		if (user) {
			args[argc++] = "-l";
			args[argc++] = user;
		}
		args[argc++] = machine;
#endif

		args[argc++] = rsync_path;

		server_options(args,&argc);
	}

	args[argc++] = ".";

	if (path && *path) 
		args[argc++] = path;

	args[argc] = NULL;

	if (verbose > 3) {
		rprintf(FINFO,"cmd=");
		for (i=0;i<argc;i++)
			rprintf(FINFO,"%s ",args[i]);
		rprintf(FINFO,"\n");
	}

	if (local_server) {
		ret = local_child(argc, args, f_in, f_out);
	} else {
		ret = piped_child(args,f_in,f_out);
	}

	if (dir) free(dir);

	return ret;

oom:
	out_of_memory("do_cmd");
	return 0; /* not reached */
}


static char *get_local_name(struct file_list *flist,char *name)
{
	STRUCT_STAT st;
	extern int orig_umask;

	if (do_stat(name,&st) == 0) {
		if (S_ISDIR(st.st_mode)) {
			if (!push_dir(name, 0)) {
				rprintf(FERROR,"push_dir %s : %s (1)\n",
					name,strerror(errno));
				exit_cleanup(1);
			}
			return NULL;
		}
		if (flist->count > 1) {
			rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
			exit_cleanup(1);
		}
		return name;
	}

	if (flist->count == 1)
		return name;

	if (!name) 
		return NULL;

	if (do_mkdir(name,0777 & ~orig_umask) != 0) {
		rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
		exit_cleanup(1);
	} else {
		rprintf(FINFO,"created directory %s\n",name);
	}

	if (!push_dir(name, 0)) {
		rprintf(FERROR,"push_dir %s : %s (2)\n",
			name,strerror(errno));
		exit_cleanup(1);
	}

	return NULL;
}


static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
{
	int i;
	struct file_list *flist;
	char *dir = argv[0];
	extern int relative_paths;
	extern int recurse;

	if (verbose > 2)
		rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
  
	if (!relative_paths && !push_dir(dir, 0)) {
		rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
		exit_cleanup(1);
	}
	argc--;
	argv++;
  
	if (strcmp(dir,".")) {
		int l = strlen(dir);
		if (strcmp(dir,"/") == 0) 
			l = 0;
		for (i=0;i<argc;i++)
			argv[i] += l+1;
	}

	if (argc == 0 && recurse) {
		argc=1;
		argv--;
		argv[0] = ".";
	}
	
	flist = send_file_list(f_out,argc,argv);
	if (!flist || flist->count == 0) {
		exit_cleanup(0);
	}

	send_files(flist,f_out,f_in);
	report(f_out);
	io_flush();
	exit_cleanup(0);
}


static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
{
	int pid;
	int status=0;
	int recv_pipe[2];
	extern int preserve_hard_links;

	if (preserve_hard_links)
		init_hard_links(flist);

	if (pipe(recv_pipe) < 0) {
		rprintf(FERROR,"pipe failed in do_recv\n");
		exit_cleanup(1);
	}
  
	io_flush();

	if ((pid=do_fork()) == 0) {
		close(recv_pipe[0]);
		if (f_in != f_out) close(f_out);

		recv_files(f_in,flist,local_name,recv_pipe[1]);
		report(f_in);

		if (verbose > 3)
			rprintf(FINFO,"do_recv waiting on %d\n",pid);

		io_flush();
		_exit(0);
	}

	close(recv_pipe[1]);
	io_close_input(f_in);
	if (f_in != f_out) close(f_in);
	generate_files(f_out,flist,local_name,recv_pipe[0]);

	io_flush();
	waitpid(pid, &status, 0);
	return status;
}


static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
{
	int status;
	struct file_list *flist;
	char *local_name=NULL;
	char *dir = NULL;
	extern int delete_mode;
	extern int am_daemon;

	if (verbose > 2)
		rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
	
	if (argc > 0) {
		dir = argv[0];
		argc--;
		argv++;
		if (!am_daemon && !push_dir(dir, 0)) {
			rprintf(FERROR,"push_dir %s : %s (4)\n",
				dir,strerror(errno));
			exit_cleanup(1);
		}    
	}

	if (delete_mode)
		recv_exclude_list(f_in);

	flist = recv_file_list(f_in);
	if (!flist || flist->count == 0) {
		rprintf(FERROR,"server_recv: nothing to do\n");
		exit_cleanup(1);
	}
	
	if (argc > 0) {    
		if (strcmp(dir,".")) {
			argv[0] += strlen(dir);
			if (argv[0][0] == '/') argv[0]++;
		}
		local_name = get_local_name(flist,argv[0]);
	}

	status = do_recv(f_in,f_out,flist,local_name);
	exit_cleanup(status);
}


void start_server(int f_in, int f_out, int argc, char *argv[])
{
	extern int cvs_exclude;
	extern int am_sender;

	setup_protocol(f_out, f_in);
	
	if (am_sender) {
		recv_exclude_list(f_in);
		if (cvs_exclude)
			add_cvs_excludes();
		do_server_sender(f_in, f_out, argc, argv);
	} else {
		do_server_recv(f_in, f_out, argc, argv);
	}
	exit_cleanup(0);
}

int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
{
	struct file_list *flist;
	int status = 0, status2 = 0;
	char *local_name = NULL;
	extern int am_sender;

	setup_protocol(f_out,f_in);
	
	if (am_sender) {
		extern int cvs_exclude;
		extern int delete_mode;
		if (cvs_exclude)
			add_cvs_excludes();
		if (delete_mode) 
			send_exclude_list(f_out);
		flist = send_file_list(f_out,argc,argv);
		if (verbose > 3) 
			rprintf(FINFO,"file list sent\n");
		send_files(flist,f_out,f_in);
		if (pid != -1) {
			if (verbose > 3)
				rprintf(FINFO,"client_run waiting on %d\n",pid);
			io_flush();
			waitpid(pid, &status, 0);
		}
		report(-1);
		exit_cleanup(status);
	}
	
	send_exclude_list(f_out);
	
	flist = recv_file_list(f_in);
	if (!flist || flist->count == 0) {
		rprintf(FINFO,"client: nothing to do\n");
		exit_cleanup(0);
	}
	
	local_name = get_local_name(flist,argv[0]);
	
	status2 = do_recv(f_in,f_out,flist,local_name);
	
	if (pid != -1) {
		if (verbose > 3)
			rprintf(FINFO,"client_run2 waiting on %d\n",pid);
		io_flush();
		waitpid(pid, &status, 0);
	}
	
	return status | status2;
}


int start_client(int argc, char *argv[])
{
	char *p;
	char *shell_machine = NULL;
	char *shell_path = NULL;
	char *shell_user = NULL;
	int pid;
	int f_in,f_out;
	extern int local_server;
	extern int am_sender;
	extern char *shell_cmd;

	p = strchr(argv[0],':');

	if (p) {
		if (p[1] == ':') {
			*p = 0;
			return start_socket_client(argv[0], p+2, argc-1, argv+1);
		}

		if (argc < 2) {
			usage(FERROR);
			exit_cleanup(1);
		}

		am_sender = 0;
		*p = 0;
		shell_machine = argv[0];
		shell_path = p+1;
		argc--;
		argv++;
	} else {
		am_sender = 1;

		p = strchr(argv[argc-1],':');
		if (!p) {
			local_server = 1;
		} else if (p[1] == ':') {
			*p = 0;
			return start_socket_client(argv[argc-1], p+2, argc-1, argv);
		}

		if (argc < 2) {
			usage(FERROR);
			exit_cleanup(1);
		}
		
		if (local_server) {
			shell_machine = NULL;
			shell_path = argv[argc-1];
		} else {
			*p = 0;
			shell_machine = argv[argc-1];
			shell_path = p+1;
		}
		argc--;
	}
	
	if (shell_machine) {
		p = strchr(shell_machine,'@');
		if (p) {
			*p = 0;
			shell_user = shell_machine;
			shell_machine = p+1;
		}
	}

	if (verbose > 3) {
		rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
			shell_cmd?shell_cmd:"",
			shell_machine?shell_machine:"",
			shell_user?shell_user:"",
			shell_path?shell_path:"");
	}
	
	if (!am_sender && argc != 1) {
		usage(FERROR);
		exit_cleanup(1);
	}
	
	pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
	
#if HAVE_SETLINEBUF
	setlinebuf(stdout);
	setlinebuf(stderr);
#endif

	return client_run(f_in, f_out, pid, argc, argv);
}


RETSIGTYPE sigusr1_handler(int val) {
	exit_cleanup(1);
}

int main(int argc,char *argv[])
{       
	extern int am_root;
	extern int orig_umask;
	extern int dry_run;
	extern int am_daemon;
	extern int am_server;

	signal(SIGUSR1, sigusr1_handler);

	starttime = time(NULL);
	am_root = (getuid() == 0);

	memset(&stats, 0, sizeof(stats));

	if (argc < 2) {
		usage(FERROR);
		exit_cleanup(1);
	}

	/* we set a 0 umask so that correct file permissions can be
	   carried across */
	orig_umask = (int)umask(0);

	parse_arguments(argc, argv);

	argc -= optind;
	argv += optind;
	optind = 0;

	signal(SIGCHLD,SIG_IGN);
	signal(SIGINT,SIGNAL_CAST sig_int);
	signal(SIGPIPE,SIGNAL_CAST sig_int);
	signal(SIGHUP,SIGNAL_CAST sig_int);

	if (am_daemon) {
		return daemon_main();
	}

	if (argc < 1) {
		usage(FERROR);
		exit_cleanup(1);
	}

	if (dry_run)
		verbose = MAX(verbose,1);

#ifndef SUPPORT_LINKS
	if (!am_server && preserve_links) {
		rprintf(FERROR,"ERROR: symbolic links not supported\n");
		exit_cleanup(1);
	}
#endif

	if (am_server) {
		start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
	}

	return start_client(argc, argv);
}
Commit	Line	Data
c627d613 AT	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
f0fca04e	22	time_t starttime = 0;
a800434a AT	23
a800434a AT	24	struct stats stats;
5d6bcd44	25
34ccb63e	26	extern int csum_length;
c627d613	27
7a6421fa	28	extern int verbose;
c627d613 AT	29
	30	static void report(int f)
	31	{
7a6421fa AT	32	time_t t = time(NULL);
	33	extern int am_server;
	34	extern int am_sender;
248fbb8c	35	extern int am_daemon;
a800434a	36	extern int do_stats;
7a6421fa	37
248fbb8c	38	if (am_daemon) {
8d9dc9f9	39	syslog(LOG_INFO,"wrote %.0f bytes read %.0f bytes total size %.0f\n",
a800434a AT	40	(double)stats.total_written,
	41	(double)stats.total_read,
	42	(double)stats.total_size);
7b372642	43	if (f == -1 \|\| !am_sender) return;
248fbb8c AT	44	}
248fbb8c AT	45
7b372642 AT	46	if (!verbose) return;
7b372642 AT	47
ba5e128d AT	48	if (am_server && !am_sender) return;
ba5e128d AT	49
7a6421fa	50	if (am_server && am_sender) {
a800434a AT	51	write_longint(f,stats.total_read);
	52	write_longint(f,stats.total_written);
	53	write_longint(f,stats.total_size);
7a6421fa AT	54	return;
7a6421fa AT	55	}
c627d613	56
a800434a AT	57	if (!am_sender) {
	58	int64 r;
	59	stats.total_written = read_longint(f);
	60	r = read_longint(f);
	61	stats.total_size = read_longint(f);
	62	stats.total_read = r;
	63	}
	64
	65	if (do_stats) {
	66	printf("\nNumber of files: %d\n", stats.num_files);
	67	printf("Number of files transferred: %d\n",
	68	stats.num_transferred_files);
	69	printf("Total file size: %.0f bytes\n",
	70	(double)stats.total_size);
	71	printf("Total transferred file size: %.0f bytes\n",
	72	(double)stats.total_transferred_size);
	73	printf("Literal data: %.0f bytes\n",
	74	(double)stats.literal_data);
	75	printf("Matched data: %.0f bytes\n",
	76	(double)stats.matched_data);
	77	printf("File list size: %d\n", stats.flist_size);
	78	printf("Total bytes written: %.0f\n",
	79	(double)stats.total_written);
	80	printf("Total bytes read: %.0f\n\n",
	81	(double)stats.total_read);
7a6421fa AT	82	}
	83
	84	printf("wrote %.0f bytes read %.0f bytes %.2f bytes/sec\n",
a800434a AT	85	(double)stats.total_written,
	86	(double)stats.total_read,
	87	(stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
7a6421fa	88	printf("total size is %.0f speedup is %.2f\n",
a800434a AT	89	(double)stats.total_size,
a800434a AT	90	(1.0*stats.total_size)/(stats.total_written+stats.total_read));
c627d613 AT	91	}
	92
	93
e3cd198f	94	static int do_cmd(char cmd,char machine,char user,char path,int f_in,int f_out)
c627d613	95	{
366345fe AT	96	char *args[100];
	97	int i,argc=0, ret;
	98	char tok,dir=NULL;
7a6421fa AT	99	extern int local_server;
7a6421fa AT	100	extern char *rsync_path;
366345fe AT	101
	102	if (!local_server) {
	103	if (!cmd)
	104	cmd = getenv(RSYNC_RSH_ENV);
	105	if (!cmd)
	106	cmd = RSYNC_RSH;
	107	cmd = strdup(cmd);
	108	if (!cmd)
	109	goto oom;
	110
	111	for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
	112	args[argc++] = tok;
	113	}
c627d613	114
7b8356d0	115	#if HAVE_REMSH
366345fe AT	116	/* remsh (on HPUX) takes the arguments the other way around */
	117	args[argc++] = machine;
	118	if (user) {
	119	args[argc++] = "-l";
	120	args[argc++] = user;
	121	}
7b8356d0	122	#else
366345fe AT	123	if (user) {
	124	args[argc++] = "-l";
	125	args[argc++] = user;
	126	}
	127	args[argc++] = machine;
7b8356d0	128	#endif
c627d613	129
366345fe	130	args[argc++] = rsync_path;
c627d613	131
366345fe AT	132	server_options(args,&argc);
366345fe AT	133	}
c627d613	134
366345fe	135	args[argc++] = ".";
76076c4b	136
366345fe AT	137	if (path && *path)
366345fe AT	138	args[argc++] = path;
c627d613	139
366345fe	140	args[argc] = NULL;
c627d613	141
366345fe	142	if (verbose > 3) {
9486289c	143	rprintf(FINFO,"cmd=");
366345fe	144	for (i=0;i<argc;i++)
9486289c AT	145	rprintf(FINFO,"%s ",args[i]);
9486289c AT	146	rprintf(FINFO,"\n");
366345fe AT	147	}
	148
	149	if (local_server) {
	150	ret = local_child(argc, args, f_in, f_out);
	151	} else {
	152	ret = piped_child(args,f_in,f_out);
	153	}
c627d613	154
366345fe	155	if (dir) free(dir);
82306bf6	156
366345fe	157	return ret;
c627d613 AT	158
c627d613 AT	159	oom:
366345fe AT	160	out_of_memory("do_cmd");
366345fe AT	161	return 0; /* not reached */
c627d613 AT	162	}
	163
	164
	165
	166
	167	static char get_local_name(struct file_list flist,char *name)
	168	{
7a6421fa AT	169	STRUCT_STAT st;
7a6421fa AT	170	extern int orig_umask;
c627d613	171
1ff5450d AT	172	if (do_stat(name,&st) == 0) {
1ff5450d AT	173	if (S_ISDIR(st.st_mode)) {
5243c216 AT	174	if (!push_dir(name, 0)) {
5243c216 AT	175	rprintf(FERROR,"push_dir %s : %s (1)\n",
1ff5450d AT	176	name,strerror(errno));
	177	exit_cleanup(1);
	178	}
	179	return NULL;
	180	}
	181	if (flist->count > 1) {
	182	rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
	183	exit_cleanup(1);
	184	}
	185	return name;
	186	}
	187
	188	if (flist->count == 1)
	189	return name;
	190
	191	if (!name)
	192	return NULL;
	193
	194	if (do_mkdir(name,0777 & ~orig_umask) != 0) {
	195	rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
	196	exit_cleanup(1);
	197	} else {
	198	rprintf(FINFO,"created directory %s\n",name);
	199	}
	200
5243c216 AT	201	if (!push_dir(name, 0)) {
	202	rprintf(FERROR,"push_dir %s : %s (2)\n",
	203	name,strerror(errno));
1ff5450d AT	204	exit_cleanup(1);
	205	}
	206
	207	return NULL;
c627d613 AT	208	}
	209
	210
	211
	212
9486289c	213	static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
c627d613	214	{
7a6421fa AT	215	int i;
	216	struct file_list *flist;
	217	char *dir = argv[0];
	218	extern int relative_paths;
7a6421fa	219	extern int recurse;
c627d613	220
7a6421fa AT	221	if (verbose > 2)
7a6421fa AT	222	rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
c627d613	223
5243c216 AT	224	if (!relative_paths && !push_dir(dir, 0)) {
5243c216 AT	225	rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
7a6421fa AT	226	exit_cleanup(1);
	227	}
	228	argc--;
	229	argv++;
c627d613	230
7a6421fa AT	231	if (strcmp(dir,".")) {
	232	int l = strlen(dir);
	233	if (strcmp(dir,"/") == 0)
	234	l = 0;
	235	for (i=0;i<argc;i++)
	236	argv[i] += l+1;
	237	}
c627d613	238
7a6421fa AT	239	if (argc == 0 && recurse) {
	240	argc=1;
	241	argv--;
	242	argv[0] = ".";
	243	}
	244
7a6421fa	245	flist = send_file_list(f_out,argc,argv);
8d9dc9f9 AT	246	if (!flist \|\| flist->count == 0) {
	247	exit_cleanup(0);
	248	}
	249
7a6421fa AT	250	send_files(flist,f_out,f_in);
7a6421fa AT	251	report(f_out);
8d9dc9f9	252	io_flush();
7a6421fa	253	exit_cleanup(0);
c627d613 AT	254	}
	255
	256
dc5ddbcc AT	257	static int do_recv(int f_in,int f_out,struct file_list flist,char local_name)
dc5ddbcc AT	258	{
d186eb1a AT	259	int pid;
	260	int status=0;
	261	int recv_pipe[2];
	262	extern int preserve_hard_links;
dc5ddbcc	263
d186eb1a AT	264	if (preserve_hard_links)
d186eb1a AT	265	init_hard_links(flist);
dc5ddbcc	266
d186eb1a AT	267	if (pipe(recv_pipe) < 0) {
d186eb1a AT	268	rprintf(FERROR,"pipe failed in do_recv\n");
8d9dc9f9	269	exit_cleanup(1);
d186eb1a	270	}
c6e7fcb4	271
8d9dc9f9	272	io_flush();
c6e7fcb4	273
d186eb1a	274	if ((pid=do_fork()) == 0) {
e08c9610 AT	275	close(recv_pipe[0]);
	276	if (f_in != f_out) close(f_out);
	277
	278	recv_files(f_in,flist,local_name,recv_pipe[1]);
ba5e128d	279	report(f_in);
e08c9610 AT	280
	281	if (verbose > 3)
	282	rprintf(FINFO,"do_recv waiting on %d\n",pid);
8d9dc9f9 AT	283
	284	io_flush();
	285	_exit(0);
d186eb1a	286	}
dc5ddbcc	287
e08c9610 AT	288	close(recv_pipe[1]);
	289	io_close_input(f_in);
	290	if (f_in != f_out) close(f_in);
	291	generate_files(f_out,flist,local_name,recv_pipe[0]);
8d9dc9f9 AT	292
8d9dc9f9 AT	293	io_flush();
d186eb1a	294	waitpid(pid, &status, 0);
d186eb1a	295	return status;
dc5ddbcc AT	296	}
dc5ddbcc AT	297
c627d613	298
9486289c	299	static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
c627d613	300	{
7a6421fa AT	301	int status;
	302	struct file_list *flist;
	303	char *local_name=NULL;
	304	char *dir = NULL;
	305	extern int delete_mode;
	306	extern int am_daemon;
f0fca04e	307
7a6421fa AT	308	if (verbose > 2)
	309	rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
	310
7a6421fa AT	311	if (argc > 0) {
	312	dir = argv[0];
	313	argc--;
	314	argv++;
5243c216 AT	315	if (!am_daemon && !push_dir(dir, 0)) {
5243c216 AT	316	rprintf(FERROR,"push_dir %s : %s (4)\n",
7a6421fa AT	317	dir,strerror(errno));
	318	exit_cleanup(1);
	319	}
	320	}
c627d613	321
7a6421fa AT	322	if (delete_mode)
7a6421fa AT	323	recv_exclude_list(f_in);
c627d613	324
7a6421fa AT	325	flist = recv_file_list(f_in);
7a6421fa AT	326	if (!flist \|\| flist->count == 0) {
8d9dc9f9	327	rprintf(FERROR,"server_recv: nothing to do\n");
7a6421fa AT	328	exit_cleanup(1);
	329	}
	330
	331	if (argc > 0) {
	332	if (strcmp(dir,".")) {
	333	argv[0] += strlen(dir);
	334	if (argv[0][0] == '/') argv[0]++;
	335	}
	336	local_name = get_local_name(flist,argv[0]);
	337	}
c627d613	338
7a6421fa AT	339	status = do_recv(f_in,f_out,flist,local_name);
7a6421fa AT	340	exit_cleanup(status);
c627d613 AT	341	}
	342
	343
9486289c	344	void start_server(int f_in, int f_out, int argc, char *argv[])
366345fe	345	{
7a6421fa AT	346	extern int cvs_exclude;
	347	extern int am_sender;
	348
	349	setup_protocol(f_out, f_in);
366345fe	350
7a6421fa AT	351	if (am_sender) {
	352	recv_exclude_list(f_in);
	353	if (cvs_exclude)
	354	add_cvs_excludes();
	355	do_server_sender(f_in, f_out, argc, argv);
	356	} else {
	357	do_server_recv(f_in, f_out, argc, argv);
	358	}
	359	exit_cleanup(0);
366345fe AT	360	}
366345fe AT	361
3591c066	362	int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
9486289c AT	363	{
	364	struct file_list *flist;
	365	int status = 0, status2 = 0;
	366	char *local_name = NULL;
7a6421fa	367	extern int am_sender;
9486289c AT	368
	369	setup_protocol(f_out,f_in);
	370
	371	if (am_sender) {
7a6421fa AT	372	extern int cvs_exclude;
7a6421fa AT	373	extern int delete_mode;
9486289c AT	374	if (cvs_exclude)
	375	add_cvs_excludes();
	376	if (delete_mode)
	377	send_exclude_list(f_out);
	378	flist = send_file_list(f_out,argc,argv);
	379	if (verbose > 3)
	380	rprintf(FINFO,"file list sent\n");
	381	send_files(flist,f_out,f_in);
	382	if (pid != -1) {
	383	if (verbose > 3)
8d9dc9f9 AT	384	rprintf(FINFO,"client_run waiting on %d\n",pid);
8d9dc9f9 AT	385	io_flush();
9486289c AT	386	waitpid(pid, &status, 0);
	387	}
	388	report(-1);
	389	exit_cleanup(status);
	390	}
	391
	392	send_exclude_list(f_out);
	393
	394	flist = recv_file_list(f_in);
	395	if (!flist \|\| flist->count == 0) {
8d9dc9f9	396	rprintf(FINFO,"client: nothing to do\n");
9486289c AT	397	exit_cleanup(0);
	398	}
	399
	400	local_name = get_local_name(flist,argv[0]);
	401
	402	status2 = do_recv(f_in,f_out,flist,local_name);
	403
9486289c	404	if (pid != -1) {
8d9dc9f9 AT	405	if (verbose > 3)
	406	rprintf(FINFO,"client_run2 waiting on %d\n",pid);
	407	io_flush();
9486289c AT	408	waitpid(pid, &status, 0);
	409	}
	410
	411	return status \| status2;
	412	}
	413
	414
5d6bcd44 AT	415	int start_client(int argc, char *argv[])
	416	{
	417	char *p;
	418	char *shell_machine = NULL;
	419	char *shell_path = NULL;
	420	char *shell_user = NULL;
9486289c	421	int pid;
5d6bcd44	422	int f_in,f_out;
7a6421fa AT	423	extern int local_server;
	424	extern int am_sender;
	425	extern char *shell_cmd;
5d6bcd44 AT	426
	427	p = strchr(argv[0],':');
	428
	429	if (p) {
9486289c AT	430	if (p[1] == ':') {
	431	*p = 0;
	432	return start_socket_client(argv[0], p+2, argc-1, argv+1);
	433	}
3591c066 AT	434
	435	if (argc < 2) {
	436	usage(FERROR);
	437	exit_cleanup(1);
	438	}
	439
5d6bcd44 AT	440	am_sender = 0;
	441	*p = 0;
	442	shell_machine = argv[0];
	443	shell_path = p+1;
	444	argc--;
	445	argv++;
	446	} else {
	447	am_sender = 1;
9486289c	448
5d6bcd44 AT	449	p = strchr(argv[argc-1],':');
	450	if (!p) {
	451	local_server = 1;
9486289c AT	452	} else if (p[1] == ':') {
	453	*p = 0;
	454	return start_socket_client(argv[argc-1], p+2, argc-1, argv);
5d6bcd44	455	}
3591c066 AT	456
	457	if (argc < 2) {
	458	usage(FERROR);
	459	exit_cleanup(1);
	460	}
9486289c	461
5d6bcd44 AT	462	if (local_server) {
	463	shell_machine = NULL;
	464	shell_path = argv[argc-1];
	465	} else {
	466	*p = 0;
	467	shell_machine = argv[argc-1];
	468	shell_path = p+1;
	469	}
	470	argc--;
	471	}
	472
	473	if (shell_machine) {
	474	p = strchr(shell_machine,'@');
	475	if (p) {
	476	*p = 0;
	477	shell_user = shell_machine;
	478	shell_machine = p+1;
	479	}
	480	}
	481
	482	if (verbose > 3) {
9486289c	483	rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
5d6bcd44 AT	484	shell_cmd?shell_cmd:"",
	485	shell_machine?shell_machine:"",
	486	shell_user?shell_user:"",
	487	shell_path?shell_path:"");
	488	}
	489
	490	if (!am_sender && argc != 1) {
	491	usage(FERROR);
	492	exit_cleanup(1);
	493	}
	494
	495	pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
	496
5d6bcd44	497	#if HAVE_SETLINEBUF
9486289c AT	498	setlinebuf(stdout);
9486289c AT	499	setlinebuf(stderr);
5d6bcd44	500	#endif
9486289c AT	501
9486289c AT	502	return client_run(f_in, f_out, pid, argc, argv);
5d6bcd44 AT	503	}
5d6bcd44 AT	504
366345fe	505
82306bf6 AT	506	RETSIGTYPE sigusr1_handler(int val) {
	507	exit_cleanup(1);
	508	}
	509
5d6bcd44	510	int main(int argc,char *argv[])
7a6421fa AT	511	{
	512	extern int am_root;
	513	extern int orig_umask;
	514	extern int dry_run;
	515	extern int am_daemon;
	516	extern int am_server;
5d6bcd44	517
7a6421fa	518	signal(SIGUSR1, sigusr1_handler);
5d6bcd44	519
7a6421fa AT	520	starttime = time(NULL);
7a6421fa AT	521	am_root = (getuid() == 0);
c627d613	522
a800434a AT	523	memset(&stats, 0, sizeof(stats));
a800434a AT	524
df5e03da AT	525	if (argc < 2) {
df5e03da AT	526	usage(FERROR);
8d9dc9f9	527	exit_cleanup(1);
df5e03da AT	528	}
df5e03da AT	529
7a6421fa AT	530	/* we set a 0 umask so that correct file permissions can be
	531	carried across */
	532	orig_umask = (int)umask(0);
5d6bcd44	533
7a6421fa	534	parse_arguments(argc, argv);
5d6bcd44	535
7a6421fa AT	536	argc -= optind;
	537	argv += optind;
	538	optind = 0;
c627d613	539
7a6421fa AT	540	signal(SIGCHLD,SIG_IGN);
	541	signal(SIGINT,SIGNAL_CAST sig_int);
	542	signal(SIGPIPE,SIGNAL_CAST sig_int);
	543	signal(SIGHUP,SIGNAL_CAST sig_int);
6b83141d	544
7a6421fa AT	545	if (am_daemon) {
	546	return daemon_main();
	547	}
f0fca04e	548
08ac228f AT	549	if (argc < 1) {
08ac228f AT	550	usage(FERROR);
8d9dc9f9	551	exit_cleanup(1);
08ac228f AT	552	}
08ac228f AT	553
7a6421fa AT	554	if (dry_run)
7a6421fa AT	555	verbose = MAX(verbose,1);
c627d613	556
cbbe4892	557	#ifndef SUPPORT_LINKS
7a6421fa AT	558	if (!am_server && preserve_links) {
	559	rprintf(FERROR,"ERROR: symbolic links not supported\n");
	560	exit_cleanup(1);
	561	}
cbbe4892 AT	562	#endif
cbbe4892 AT	563
7a6421fa AT	564	if (am_server) {
	565	start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
	566	}
c627d613	567
7a6421fa	568	return start_client(argc, argv);
c627d613	569	}
82306bf6	570