X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/45c5b903eb96bc57ed1b4d59586defb1e4d0dc53..184dd27a183ab3403eadbd699bc47a1f96cdd331:/clientserver.c

diff --git a/clientserver.c b/clientserver.c
index 7c46c707..c0ace0c5 100644
--- a/clientserver.c
+++ b/clientserver.c
@@ -41,7 +41,6 @@ extern int filesfrom_fd;
 extern int remote_protocol;
 extern int protocol_version;
 extern int io_timeout;
-extern int select_timeout;
 extern int orig_umask;
 extern int no_detach;
 extern int default_af_hint;
@@ -49,6 +48,7 @@ extern char *bind_address;
 extern struct filter_list_struct server_filter_list;
 extern char *config_file;
 extern char *files_from;
+extern char *tmpdir;
 
 char *auth_user;
 int read_only = 0;
@@ -59,6 +59,8 @@ int module_id = -1;
 /* Length of lp_path() string when in daemon mode & not chrooted, else 0. */
 unsigned int module_dirlen = 0;
 
+#define MAX_REQ_LEN (MAXPATHLEN + 255)
+
 /**
  * Run a client connected to an rsyncd.  The alternative to this
  * function for remote-shell connections is do_cmd().
@@ -109,7 +111,7 @@ int start_inband_exchange(char *user, char *path, int f_in, int f_out,
 	int i;
 	char *sargs[MAX_ARGS];
 	int sargc = 0;
-	char line[MAXPATHLEN];
+	char line[BIGPATHBUFLEN];
 	char *p;
 
 	if (argc == 0 && !am_sender)
@@ -216,24 +218,44 @@ int start_inband_exchange(char *user, char *path, int f_in, int f_out,
 	return 0;
 }
 
+static char *finish_pre_exec(pid_t pid, int fd, char *request)
+{
+	int status = -1;
 
+	if (request) {
+		int len = strlen(request);
+		if (len > MAX_REQ_LEN)
+			len = MAX_REQ_LEN;
+		write(fd, request, len);
+	}
+	close(fd);
+
+	if (wait_process(pid, &status, 0) < 0
+	 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+		char *e;
+		if (asprintf(&e, "pre-xfer exec returned failure (%d)\n", status) < 0)
+			out_of_memory("finish_pre_exec");
+		return e;
+	}
+	return NULL;
+}
 
 static int rsync_module(int f_in, int f_out, int i)
 {
 	int argc = 0;
 	int maxargs;
 	char **argv;
-	char **argp;
-	char line[MAXPATHLEN];
+	char line[BIGPATHBUFLEN];
 	uid_t uid = (uid_t)-2;  /* canonically "nobody" */
 	gid_t gid = (gid_t)-2;
-	char *p;
+	char *p, *err_msg = NULL;
 	char *addr = client_addr(f_in);
 	char *host = client_name(f_in);
 	char *name = lp_name(i);
 	int use_chroot = lp_use_chroot(i);
 	int start_glob = 0;
-	int ret;
+	int ret, pre_exec_fd = -1;
+	pid_t pre_exec_pid = 0;
 	char *request = NULL;
 
 	if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
@@ -327,27 +349,107 @@ static int rsync_module(int f_in, int f_out, int i)
 
 	p = lp_filter(i);
 	parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
-		   XFLG_ANCHORED2ABS);
+		   XFLG_ABS_IF_SLASH);
 
 	p = lp_include_from(i);
 	parse_filter_file(&server_filter_list, p, MATCHFLG_INCLUDE,
-	    XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
+	    XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
 
 	p = lp_include(i);
 	parse_rule(&server_filter_list, p,
 		   MATCHFLG_INCLUDE | MATCHFLG_WORD_SPLIT,
-		   XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES);
+		   XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES);
 
 	p = lp_exclude_from(i);
 	parse_filter_file(&server_filter_list, p, 0,
-	    XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
+	    XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
 
 	p = lp_exclude(i);
 	parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
-		   XFLG_ANCHORED2ABS | XFLG_OLD_PREFIXES);
+		   XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES);
 
 	log_init();
 
+#ifdef HAVE_PUTENV
+	if (*lp_prexfer_exec(i) || *lp_postxfer_exec(i)) {
+		char *modname, *modpath, *hostaddr, *hostname, *username;
+		int status;
+		if (asprintf(&modname, "RSYNC_MODULE_NAME=%s", name) < 0
+		 || asprintf(&modpath, "RSYNC_MODULE_PATH=%s", lp_path(i)) < 0
+		 || asprintf(&hostaddr, "RSYNC_HOST_ADDR=%s", addr) < 0
+		 || asprintf(&hostname, "RSYNC_HOST_NAME=%s", host) < 0
+		 || asprintf(&username, "RSYNC_USER_NAME=%s", auth_user) < 0)
+			out_of_memory("rsync_module");
+		putenv(modname);
+		putenv(modpath);
+		putenv(hostaddr);
+		putenv(hostname);
+		putenv(username);
+		umask(orig_umask);
+		/* For post-xfer exec, fork a new process to run the rsync
+		 * daemon while this process waits for the exit status and
+		 * runs the indicated command at that point. */
+		if (*lp_postxfer_exec(i)) {
+			pid_t pid = fork();
+			if (pid < 0) {
+				rsyserr(FLOG, errno, "fork failed");
+				io_printf(f_out, "@ERROR: fork failed\n");
+				return -1;
+			}
+			if (pid) {
+				char *ret1, *ret2;
+				if (wait_process(pid, &status, 0) < 0)
+					status = -1;
+				if (asprintf(&ret1, "RSYNC_RAW_STATUS=%d", status) > 0)
+					putenv(ret1);
+				if (WIFEXITED(status))
+					status = WEXITSTATUS(status);
+				else
+					status = -1;
+				if (asprintf(&ret2, "RSYNC_EXIT_STATUS=%d", status) > 0)
+					putenv(ret2);
+				system(lp_postxfer_exec(i));
+				_exit(status);
+			}
+		}
+		/* For pre-xfer exec, fork a child process to run the indicated
+		 * command, though it first waits for the parent process to
+		 * send us the user's request via a pipe. */
+		if (*lp_prexfer_exec(i)) {
+			int fds[2];
+			if (pipe(fds) < 0 || (pre_exec_pid = fork()) < 0) {
+				rsyserr(FLOG, errno, "pre-xfer exec preparation failed");
+				io_printf(f_out, "@ERROR: pre-xfer exec preparation failed\n");
+				return -1;
+			}
+			if (pre_exec_pid == 0) {
+				char buf[MAX_REQ_LEN+1];
+				int len;
+				close(fds[1]);
+				set_blocking(fds[0]);
+				len = read(fds[0], buf, MAX_REQ_LEN);
+				close(fds[0]);
+				if (len <= 0)
+					_exit(1);
+				buf[len] = '\0';
+				if (asprintf(&p, "RSYNC_REQUEST=%s", buf) < 0)
+					out_of_memory("rsync_module");
+				putenv(p);
+				close(STDIN_FILENO);
+				close(STDOUT_FILENO);
+				status = system(lp_prexfer_exec(i));
+				if (!WIFEXITED(status))
+					_exit(1);
+				_exit(WEXITSTATUS(status));
+			}
+			close(fds[0]);
+			set_blocking(fds[1]);
+			pre_exec_fd = fds[1];
+		}
+		umask(0);
+	}
+#endif
+
 	if (use_chroot) {
 		/*
 		 * XXX: The 'use chroot' flag is a fairly reliable
@@ -420,6 +522,16 @@ static int rsync_module(int f_in, int f_out, int i)
 		am_root = (MY_UID() == 0);
 	}
 
+	if (lp_temp_dir(i) && *lp_temp_dir(i)) {
+		tmpdir = lp_temp_dir(i);
+		if (strlen(tmpdir) >= MAXPATHLEN - 10) {
+			rprintf(FLOG,
+				"the 'temp dir' value for %s is WAY too long -- ignoring.\n",
+				name);
+			tmpdir = NULL;
+		}
+	}
+
 	io_printf(f_out, "@RSYNCD: OK\n");
 
 	maxargs = MAX_ARGS;
@@ -444,22 +556,33 @@ static int rsync_module(int f_in, int f_out, int i)
 		if (!(argv[argc] = strdup(p)))
 			out_of_memory("rsync_module");
 
-		if (start_glob) {
-			if (start_glob == 1) {
-				request = strdup(p);
-				start_glob++;
-			}
-			glob_expand(name, &argv, &argc, &maxargs);
-		} else
+		switch (start_glob) {
+		case 0:
 			argc++;
-
-		if (strcmp(line, ".") == 0)
-			start_glob = 1;
+			if (strcmp(line, ".") == 0)
+				start_glob = 1;
+			break;
+		case 1:
+			if (pre_exec_pid) {
+				err_msg = finish_pre_exec(pre_exec_pid,
+							  pre_exec_fd, p);
+				pre_exec_pid = 0;
+			}
+			request = strdup(p);
+			start_glob = 2;
+			/* FALL THROUGH */
+		default:
+			if (!err_msg)
+				glob_expand(name, &argv, &argc, &maxargs);
+			break;
+		}
 	}
 
+	if (pre_exec_pid)
+		err_msg = finish_pre_exec(pre_exec_pid, pre_exec_fd, request);
+
 	verbose = 0; /* future verbosity is controlled by client options */
-	argp = argv;
-	ret = parse_arguments(&argc, (const char ***) &argp, 0);
+	ret = parse_arguments(&argc, (const char ***) &argv, 0);
 
 	if (filesfrom_fd == 0)
 		filesfrom_fd = f_in;
@@ -479,14 +602,14 @@ static int rsync_module(int f_in, int f_out, int i)
 
 #ifndef DEBUG
 	/* don't allow the logs to be flooded too fast */
-	if (verbose > lp_max_verbosity())
-		verbose = lp_max_verbosity();
+	if (verbose > lp_max_verbosity(i))
+		verbose = lp_max_verbosity(i);
 #endif
 
 	if (protocol_version < 23
 	    && (protocol_version == 22 || am_sender))
 		io_start_multiplex_out();
-	else if (!ret) {
+	else if (!ret || err_msg) {
 		/* We have to get I/O multiplexing started so that we can
 		 * get the error back to the client.  This means getting
 		 * the protocol setup finished first in later versions. */
@@ -512,19 +635,19 @@ static int rsync_module(int f_in, int f_out, int i)
 		io_start_multiplex_out();
 	}
 
-	if (!ret) {
-		option_error();
+	if (!ret || err_msg) {
+		if (err_msg)
+			rprintf(FERROR, err_msg);
+		else
+			option_error();
 		msleep(400);
 		exit_cleanup(RERR_UNSUPPORTED);
 	}
 
-	if (lp_timeout(i)) {
-		io_timeout = lp_timeout(i);
-		if (io_timeout < select_timeout)
-			select_timeout = io_timeout;
-	}
+	if (lp_timeout(i) && lp_timeout(i) > io_timeout)
+		set_io_timeout(lp_timeout(i));
 
-	start_server(f_in, f_out, argc, argp);
+	start_server(f_in, f_out, argc, argv);
 
 	return 0;
 }
@@ -550,7 +673,7 @@ static void send_listing(int fd)
    here */
 int start_daemon(int f_in, int f_out)
 {
-	char line[200];
+	char line[1024];
 	char *motd;
 	int i;
 
@@ -621,7 +744,6 @@ int start_daemon(int f_in, int f_out)
 	return rsync_module(f_in, f_out, i);
 }
 
-
 int daemon_main(void)
 {
 	char *pid_file;