+#ifdef HAVE_MALLINFO
+ struct mallinfo mi;
+
+ mi = mallinfo();
+
+ rprintf(FINFO, "\n" RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
+ getpid(), am_server ? "server " : "",
+ am_daemon ? "daemon " : "", who_am_i());
+ rprintf(FINFO, " arena: %10ld (bytes from sbrk)\n",
+ (long)mi.arena);
+ rprintf(FINFO, " ordblks: %10ld (chunks not in use)\n",
+ (long)mi.ordblks);
+ rprintf(FINFO, " smblks: %10ld\n",
+ (long)mi.smblks);
+ rprintf(FINFO, " hblks: %10ld (chunks from mmap)\n",
+ (long)mi.hblks);
+ rprintf(FINFO, " hblkhd: %10ld (bytes from mmap)\n",
+ (long)mi.hblkhd);
+ rprintf(FINFO, " allmem: %10ld (bytes from sbrk + mmap)\n",
+ (long)mi.arena + mi.hblkhd);
+ rprintf(FINFO, " usmblks: %10ld\n",
+ (long)mi.usmblks);
+ rprintf(FINFO, " fsmblks: %10ld\n",
+ (long)mi.fsmblks);
+ rprintf(FINFO, " uordblks: %10ld (bytes used)\n",
+ (long)mi.uordblks);
+ rprintf(FINFO, " fordblks: %10ld (bytes free)\n",
+ (long)mi.fordblks);
+ rprintf(FINFO, " keepcost: %10ld (bytes in releasable chunk)\n",
+ (long)mi.keepcost);
+#endif /* HAVE_MALLINFO */
+}
+
+
+/* Start the remote shell. cmd may be NULL to use the default. */
+static pid_t do_cmd(char *cmd, char *machine, char *user, char *path,
+ int *f_in, int *f_out)
+{
+ int i, argc = 0;
+ char *args[MAX_ARGS];
+ pid_t ret;
+ char *dir = NULL;
+ int dash_l_set = 0;
+
+ if (!read_batch && !local_server) {
+ char *t, *f, in_quote = '\0';
+ char *rsh_env = getenv(RSYNC_RSH_ENV);
+ if (!cmd)
+ cmd = rsh_env;
+ if (!cmd)
+ cmd = RSYNC_RSH;
+ cmd = strdup(cmd);
+ if (!cmd)
+ goto oom;
+
+ for (t = f = cmd; *f; f++) {
+ if (*f == ' ')
+ continue;
+ /* Comparison leaves rooms for server_options(). */
+ if (argc >= MAX_ARGS - MAX_SERVER_ARGS) {
+ rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
+ exit_cleanup(RERR_SYNTAX);
+ }
+ args[argc++] = t;
+ while (*f != ' ' || in_quote) {
+ if (!*f) {
+ if (in_quote) {
+ rprintf(FERROR,
+ "Missing trailing-%c in remote-shell command.\n",
+ in_quote);
+ exit_cleanup(RERR_SYNTAX);
+ }
+ f--;
+ break;
+ }
+ if (*f == '\'' || *f == '"') {
+ if (!in_quote) {
+ in_quote = *f++;
+ continue;
+ }
+ if (*f == in_quote && *++f != in_quote) {
+ in_quote = '\0';
+ continue;
+ }
+ }
+ *t++ = *f++;
+ }
+ *t++ = '\0';
+ }
+
+ /* check to see if we've already been given '-l user' in
+ * the remote-shell command */
+ for (i = 0; i < argc-1; i++) {
+ if (!strcmp(args[i], "-l") && args[i+1][0] != '-')
+ dash_l_set = 1;
+ }
+
+#ifdef HAVE_REMSH
+ /* remsh (on HPUX) takes the arguments the other way around */
+ args[argc++] = machine;
+ if (user && !(daemon_over_rsh && dash_l_set)) {
+ args[argc++] = "-l";
+ args[argc++] = user;
+ }
+#else
+ if (user && !(daemon_over_rsh && dash_l_set)) {
+ args[argc++] = "-l";
+ args[argc++] = user;
+ }
+ args[argc++] = machine;
+#endif
+
+ args[argc++] = rsync_path;
+
+ if (blocking_io < 0) {
+ char *cp;
+ if ((cp = strrchr(cmd, '/')) != NULL)
+ cp++;
+ else
+ cp = cmd;
+ if (strcmp(cp, "rsh") == 0 || strcmp(cp, "remsh") == 0)
+ blocking_io = 1;
+ }
+
+ server_options(args,&argc);
+
+ if (argc >= MAX_ARGS - 2) {
+ rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
+ exit_cleanup(RERR_SYNTAX);
+ }
+ }
+
+ args[argc++] = ".";
+
+ if (!daemon_over_rsh && path && *path)
+ args[argc++] = path;
+
+ args[argc] = NULL;
+
+ if (verbose > 3) {
+ for (i = 0; i < argc; i++)
+ rprintf(FINFO, "cmd[%d]=%s ", i, args[i]);
+ rprintf(FINFO, "\n");
+ }
+
+ if (read_batch) {
+ int from_gen_pipe[2];
+ if (fd_pair(from_gen_pipe) < 0) {
+ rsyserr(FERROR, errno, "pipe");
+ exit_cleanup(RERR_IPC);
+ }
+ batch_gen_fd = from_gen_pipe[0];
+ *f_out = from_gen_pipe[1];
+ *f_in = batch_fd;
+ ret = -1; /* no child pid */
+ } else if (local_server) {
+ /* If the user didn't request --[no-]whole-file, force
+ * it on, but only if we're not batch processing. */
+ if (whole_file < 0 && !write_batch)
+ whole_file = 1;
+ ret = local_child(argc, args, f_in, f_out, child_main);
+ } 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 */
+}
+
+/* The receiving side operates in one of two modes:
+ *
+ * 1. it enters a directory and receives one or more files, placing them
+ * according to their names in the file-list.
+ *
+ * 2. it receives a single file and saves it using the name in the
+ * destination path instead of its file-list name. This requires a
+ * "local name" for writing out the destination file.
+ *
+ * So, our task is to figure out what mode/local-name we need and return
+ * either a NULL for mode 1, or the local-name for mode 2. We also
+ * change directory if there are any path components in dest_path. */
+static char *get_local_name(struct file_list *flist, char *dest_path)
+{
+ STRUCT_STAT st;
+ char *cp;
+
+ if (verbose > 2) {
+ rprintf(FINFO, "get_local_name count=%d %s\n",
+ flist->count, NS(dest_path));
+ }
+
+ if (!dest_path)
+ return NULL;
+
+ /* If the destination path refers to an existing directory, enter
+ * it and use mode 1. If there is something other than a directory
+ * at the destination path, we must be transferring one file
+ * (anything at the destination will be overwritten). */
+ if (do_stat(dest_path, &st) == 0) {
+ if (S_ISDIR(st.st_mode)) {
+ if (!push_dir(dest_path)) {
+ rsyserr(FERROR, errno, "push_dir#1 %s failed",
+ full_fname(dest_path));
+ exit_cleanup(RERR_FILESELECT);
+ }
+ return NULL;
+ }
+ if (flist->count > 1) {
+ rprintf(FERROR,
+ "ERROR: destination must be a directory when"
+ " copying more than 1 file\n");
+ exit_cleanup(RERR_FILESELECT);
+ }
+ }
+
+ cp = strrchr(dest_path, '/');
+
+ /* If the destination path ends in a slash or we are transferring
+ * multiple files, create a directory at the destination path,
+ * enter the new directory, and use mode 1. */
+ if (flist->count > 1 || (cp && !cp[1])) {
+ /* Lop off the final slash (if any). */
+ if (cp && !cp[1])
+ *cp = '\0';
+
+ umask(orig_umask);
+ if (do_mkdir(dest_path, 0777) != 0) {
+ rsyserr(FERROR, errno, "mkdir %s failed",
+ full_fname(dest_path));
+ exit_cleanup(RERR_FILEIO);
+ }
+ umask(0);
+
+ if (verbose)
+ rprintf(FINFO, "created directory %s\n", dest_path);
+
+ if (dry_run) {
+ /* Indicate that the destination directory doesn't
+ * really exist and return mode 1. */
+ dry_run++;
+ return NULL;
+ }
+
+ if (!push_dir(dest_path)) {
+ rsyserr(FERROR, errno, "push_dir#2 %s failed",
+ full_fname(dest_path));
+ exit_cleanup(RERR_FILESELECT);
+ }
+
+ return NULL;
+ }
+
+ /* Otherwise, we are writing a single file, possibly on top of an
+ * existing non-directory. Change to the item's parent directory
+ * (if it has a path component), return the basename of the
+ * destination file as the local name, and use mode 2. */
+ if (!cp)
+ return dest_path;
+
+ if (cp == dest_path)
+ dest_path = "/";
+
+ *cp = '\0';
+ if (!push_dir(dest_path)) {
+ rsyserr(FERROR, errno, "push_dir#3 %s failed",
+ full_fname(dest_path));
+ exit_cleanup(RERR_FILESELECT);
+ }
+ *cp = '/';
+
+ return cp + 1;
+}
+
+
+/* This is only called by the sender. */
+static void read_final_goodbye(int f_in, int f_out)
+{
+ int i;
+
+ if (protocol_version < 29)
+ i = read_int(f_in);
+ else {
+ while ((i = read_int(f_in)) == the_file_list->count
+ && read_shortint(f_in) == ITEM_IS_NEW) {
+ /* Forward the keep-alive (no-op) to the receiver. */
+ write_int(f_out, the_file_list->count);
+ write_shortint(f_out, ITEM_IS_NEW);
+ }
+ }
+
+ if (i != -1) {
+ rprintf(FERROR, "Invalid packet at end of run (%d) [%s]\n",
+ i, who_am_i());
+ exit_cleanup(RERR_PROTOCOL);
+ }
+}
+
+
+static void do_server_sender(int f_in, int f_out, int argc, char *argv[])
+{
+ struct file_list *flist;
+ char *dir = argv[0];
+
+ if (verbose > 2) {
+ rprintf(FINFO, "server_sender starting pid=%ld\n",
+ (long)getpid());
+ }
+
+ if (am_daemon && lp_write_only(module_id)) {
+ rprintf(FERROR, "ERROR: module is write only\n");
+ exit_cleanup(RERR_SYNTAX);
+ return;
+ }
+ if (am_daemon && lp_read_only(module_id) && remove_sent_files) {
+ rprintf(FERROR,
+ "ERROR: --remove-sent-files cannot be used with a read-only module\n");
+ exit_cleanup(RERR_SYNTAX);
+ return;
+ }
+
+ if (!relative_paths && !push_dir(dir)) {
+ rsyserr(FERROR, errno, "push_dir#3 %s failed",
+ full_fname(dir));
+ exit_cleanup(RERR_FILESELECT);
+ }
+ argc--;
+ argv++;
+
+ if (argc == 0 && (recurse || list_only)) {
+ argc = 1;
+ argv--;
+ argv[0] = ".";
+ }
+
+ flist = send_file_list(f_out,argc,argv);
+ if (!flist || flist->count == 0) {
+ exit_cleanup(0);
+ }
+ the_file_list = flist;
+
+ io_start_buffering_in();
+ io_start_buffering_out();
+
+ send_files(flist,f_out,f_in);
+ io_flush(FULL_FLUSH);
+ handle_stats(f_out);
+ if (protocol_version >= 24)
+ read_final_goodbye(f_in, f_out);
+ io_flush(FULL_FLUSH);
+ exit_cleanup(0);
+}
+
+
+static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
+{
+ int pid;
+ int exit_code = 0;
+ int error_pipe[2];
+
+ /* The receiving side mustn't obey this, or an existing symlink that
+ * points to an identical file won't be replaced by the referent. */
+ copy_links = 0;
+
+ if (preserve_hard_links)
+ init_hard_links();
+
+ if (fd_pair(error_pipe) < 0) {
+ rsyserr(FERROR, errno, "pipe failed in do_recv");
+ exit_cleanup(RERR_IPC);
+ }
+
+ io_flush(NORMAL_FLUSH);
+
+ if ((pid = do_fork()) == -1) {
+ rsyserr(FERROR, errno, "fork failed in do_recv");
+ exit_cleanup(RERR_IPC);
+ }
+
+ if (pid == 0) {
+ close(error_pipe[0]);
+ if (f_in != f_out)
+ close(f_out);
+
+ /* we can't let two processes write to the socket at one time */
+ close_multiplexing_out();
+
+ /* set place to send errors */
+ set_msg_fd_out(error_pipe[1]);
+
+ recv_files(f_in, flist, local_name);
+ io_flush(FULL_FLUSH);
+ handle_stats(f_in);
+
+ send_msg(MSG_DONE, "", 0);
+ io_flush(FULL_FLUSH);
+
+ /* Handle any keep-alive packets from the post-processing work
+ * that the generator does. */
+ if (protocol_version >= 29) {
+ kluge_around_eof = -1;
+
+ /* This should only get stopped via a USR2 signal. */
+ while (read_int(f_in) == flist->count
+ && read_shortint(f_in) == ITEM_IS_NEW) {}
+
+ rprintf(FERROR, "Invalid packet at end of run [%s]\n",
+ who_am_i());
+ exit_cleanup(RERR_PROTOCOL);
+ }
+
+ /* Finally, we go to sleep until our parent kills us with a
+ * USR2 signal. We sleep for a short time, as on some OSes
+ * a signal won't interrupt a sleep! */
+ while (1)
+ msleep(20);
+ }
+
+ am_generator = 1;
+ close_multiplexing_in();
+ if (write_batch && !am_server)
+ stop_write_batch();
+
+ close(error_pipe[1]);
+ if (f_in != f_out)
+ close(f_in);
+
+ io_start_buffering_out();
+
+ set_msg_fd_in(error_pipe[0]);
+
+ generate_files(f_out, flist, local_name);
+
+ handle_stats(-1);
+ io_flush(FULL_FLUSH);
+ if (protocol_version >= 24) {
+ /* send a final goodbye message */
+ write_int(f_out, -1);
+ }
+ io_flush(FULL_FLUSH);
+
+ set_msg_fd_in(-1);
+ kill(pid, SIGUSR2);
+ wait_process_with_flush(pid, &exit_code);
+ return exit_code;