2 * The startup routines, including main(), for rsync.
4 * Copyright (C) 1996-2001 Andrew Tridgell <tridge@samba.org>
5 * Copyright (C) 1996 Paul Mackerras
6 * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
7 * Copyright (C) 2003-2008 Wayne Davison
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, visit the http://fsf.org website.
26 #if defined CONFIG_LOCALE && defined HAVE_LOCALE_H
36 extern int inc_recurse
;
37 extern int blocking_io
;
38 extern int human_readable
;
39 extern int always_checksum
;
40 extern int remove_source_files
;
41 extern int output_needs_newline
;
42 extern int need_messages_from_generator
;
43 extern int kluge_around_eof
;
44 extern int got_xfer_error
;
45 extern int msgs2stderr
;
47 extern int copy_links
;
48 extern int copy_dirlinks
;
49 extern int copy_unsafe_links
;
50 extern int keep_dirlinks
;
51 extern int preserve_hard_links
;
52 extern int protocol_version
;
53 extern int file_total
;
56 extern int protect_args
;
57 extern int relative_paths
;
58 extern int sanitize_paths
;
59 extern int curr_dir_depth
;
60 extern int curr_dir_len
;
62 extern int rsync_port
;
63 extern int whole_file
;
64 extern int read_batch
;
65 extern int write_batch
;
67 extern int filesfrom_fd
;
68 extern int connect_timeout
;
69 extern pid_t cleanup_child_pid
;
70 extern unsigned int module_dirlen
;
71 extern struct stats stats
;
72 extern char *stdout_format
;
73 extern char *logfile_format
;
74 extern char *filesfrom_host
;
75 extern char *partial_dir
;
76 extern char *dest_option
;
77 extern char *rsync_path
;
78 extern char *shell_cmd
;
79 extern char *batch_name
;
80 extern char *password_file
;
81 extern char curr_dir
[MAXPATHLEN
];
82 extern char *basis_dir
[MAX_BASIS_DIRS
+1];
83 extern struct file_list
*first_flist
;
84 extern struct filter_list_struct daemon_filter_list
;
89 int daemon_over_rsh
= 0;
90 mode_t orig_umask
= 0;
91 int batch_gen_fd
= -1;
92 int sender_keeps_checksum
= 0;
94 /* There's probably never more than at most 2 outstanding child processes,
95 * but set it higher, just in case. */
96 #define MAXCHILDPROCS 7
99 # ifdef HAVE_SIGPROCMASK
100 # define SIGACTMASK(n,h) SIGACTION(n,h), sigaddset(&sigmask,(n))
102 # define SIGACTMASK(n,h) SIGACTION(n,h)
104 static struct sigaction sigact
;
110 } pid_stat_table
[MAXCHILDPROCS
];
112 static time_t starttime
, endtime
;
113 static int64 total_read
, total_written
;
115 static void show_malloc_stats(void);
117 /* Works like waitpid(), but if we already harvested the child pid in our
118 * remember_children(), we succeed instead of returning an error. */
119 pid_t
wait_process(pid_t pid
, int *status_ptr
, int flags
)
124 waited_pid
= waitpid(pid
, status_ptr
, flags
);
125 } while (waited_pid
== -1 && errno
== EINTR
);
127 if (waited_pid
== -1 && errno
== ECHILD
) {
128 /* Status of requested child no longer available: check to
129 * see if it was processed by remember_children(). */
131 for (cnt
= 0; cnt
< MAXCHILDPROCS
; cnt
++) {
132 if (pid
== pid_stat_table
[cnt
].pid
) {
133 *status_ptr
= pid_stat_table
[cnt
].status
;
134 pid_stat_table
[cnt
].pid
= 0;
143 /* Wait for a process to exit, calling io_flush while waiting. */
144 static void wait_process_with_flush(pid_t pid
, int *exit_code_ptr
)
149 while ((waited_pid
= wait_process(pid
, &status
, WNOHANG
)) == 0) {
151 io_flush(FULL_FLUSH
);
154 /* TODO: If the child exited on a signal, then log an
155 * appropriate error message. Perhaps we should also accept a
156 * message describing the purpose of the child. Also indicate
157 * this to the caller so that they know something went wrong. */
158 if (waited_pid
< 0) {
159 rsyserr(FERROR
, errno
, "waitpid");
160 *exit_code_ptr
= RERR_WAITCHILD
;
161 } else if (!WIFEXITED(status
)) {
163 if (WCOREDUMP(status
))
164 *exit_code_ptr
= RERR_CRASHED
;
167 if (WIFSIGNALED(status
))
168 *exit_code_ptr
= RERR_TERMINATED
;
170 *exit_code_ptr
= RERR_WAITCHILD
;
172 *exit_code_ptr
= WEXITSTATUS(status
);
175 /* This function gets called from all 3 processes. We want the client side
176 * to actually output the text, but the sender is the only process that has
177 * all the stats we need. So, if we're a client sender, we do the report.
178 * If we're a server sender, we write the stats on the supplied fd. If
179 * we're the client receiver we read the stats from the supplied fd and do
180 * the report. All processes might also generate a set of debug stats, if
181 * the verbose level is high enough (this is the only thing that the
182 * generator process and the server receiver ever do here). */
183 static void handle_stats(int f
)
185 endtime
= time(NULL
);
187 /* Cache two stats because the read/write code can change it. */
188 total_read
= stats
.total_read
;
189 total_written
= stats
.total_written
;
191 if (INFO_GTE(STATS
, 3)) {
192 /* These come out from every process */
201 if (f
== -1 || !am_sender
)
207 write_varlong30(f
, total_read
, 3);
208 write_varlong30(f
, total_written
, 3);
209 write_varlong30(f
, stats
.total_size
, 3);
210 if (protocol_version
>= 29) {
211 write_varlong30(f
, stats
.flist_buildtime
, 3);
212 write_varlong30(f
, stats
.flist_xfertime
, 3);
218 /* this is the client */
220 if (f
< 0 && !am_sender
) /* e.g. when we got an empty file list. */
222 else if (!am_sender
) {
223 /* Read the first two in opposite order because the meaning of
224 * read/write swaps when switching from sender to receiver. */
225 total_written
= read_varlong30(f
, 3);
226 total_read
= read_varlong30(f
, 3);
227 stats
.total_size
= read_varlong30(f
, 3);
228 if (protocol_version
>= 29) {
229 stats
.flist_buildtime
= read_varlong30(f
, 3);
230 stats
.flist_xfertime
= read_varlong30(f
, 3);
232 } else if (write_batch
) {
233 /* The --read-batch process is going to be a client
234 * receiver, so we need to give it the stats. */
235 write_varlong30(batch_fd
, total_read
, 3);
236 write_varlong30(batch_fd
, total_written
, 3);
237 write_varlong30(batch_fd
, stats
.total_size
, 3);
238 if (protocol_version
>= 29) {
239 write_varlong30(batch_fd
, stats
.flist_buildtime
, 3);
240 write_varlong30(batch_fd
, stats
.flist_xfertime
, 3);
245 static void output_summary(void)
247 if (INFO_GTE(STATS
, 2)) {
248 rprintf(FCLIENT
, "\n");
249 rprintf(FINFO
,"Number of files: %d\n", stats
.num_files
);
250 rprintf(FINFO
,"Number of files transferred: %d\n",
251 stats
.num_transferred_files
);
252 rprintf(FINFO
,"Total file size: %s bytes\n",
253 big_num(stats
.total_size
, human_readable
));
254 rprintf(FINFO
,"Total transferred file size: %s bytes\n",
255 big_num(stats
.total_transferred_size
, human_readable
));
256 rprintf(FINFO
,"Literal data: %s bytes\n",
257 big_num(stats
.literal_data
, human_readable
));
258 rprintf(FINFO
,"Matched data: %s bytes\n",
259 big_num(stats
.matched_data
, human_readable
));
260 rprintf(FINFO
,"File list size: %s\n",
261 big_num(stats
.flist_size
, human_readable
));
262 if (stats
.flist_buildtime
) {
264 "File list generation time: %.3f seconds\n",
265 (double)stats
.flist_buildtime
/ 1000);
267 "File list transfer time: %.3f seconds\n",
268 (double)stats
.flist_xfertime
/ 1000);
270 rprintf(FINFO
,"Total bytes sent: %s\n",
271 big_num(total_written
, human_readable
));
272 rprintf(FINFO
,"Total bytes received: %s\n",
273 big_num(total_read
, human_readable
));
276 if (INFO_GTE(STATS
, 1)) {
277 rprintf(FCLIENT
, "\n");
279 "sent %s bytes received %s bytes %s bytes/sec\n",
280 big_num(total_written
, human_readable
),
281 big_num(total_read
, human_readable
),
282 human_dnum((total_written
+ total_read
)/(0.5 + (endtime
- starttime
)), 2));
283 rprintf(FINFO
, "total size is %s speedup is %.2f%s\n",
284 big_num(stats
.total_size
, human_readable
),
285 (double)stats
.total_size
/ (total_written
+total_read
),
286 write_batch
< 0 ? " (BATCH ONLY)" : dry_run
? " (DRY RUN)" : "");
295 * If our C library can get malloc statistics, then show them to FINFO
297 static void show_malloc_stats(void)
304 rprintf(FCLIENT
, "\n");
305 rprintf(FINFO
, RSYNC_NAME
"[%d] (%s%s%s) heap statistics:\n",
306 getpid(), am_server
? "server " : "",
307 am_daemon
? "daemon " : "", who_am_i());
308 rprintf(FINFO
, " arena: %10ld (bytes from sbrk)\n",
310 rprintf(FINFO
, " ordblks: %10ld (chunks not in use)\n",
312 rprintf(FINFO
, " smblks: %10ld\n",
314 rprintf(FINFO
, " hblks: %10ld (chunks from mmap)\n",
316 rprintf(FINFO
, " hblkhd: %10ld (bytes from mmap)\n",
318 rprintf(FINFO
, " allmem: %10ld (bytes from sbrk + mmap)\n",
319 (long)mi
.arena
+ mi
.hblkhd
);
320 rprintf(FINFO
, " usmblks: %10ld\n",
322 rprintf(FINFO
, " fsmblks: %10ld\n",
324 rprintf(FINFO
, " uordblks: %10ld (bytes used)\n",
326 rprintf(FINFO
, " fordblks: %10ld (bytes free)\n",
328 rprintf(FINFO
, " keepcost: %10ld (bytes in releasable chunk)\n",
330 #endif /* HAVE_MALLINFO */
334 /* Start the remote shell. cmd may be NULL to use the default. */
335 static pid_t
do_cmd(char *cmd
, char *machine
, char *user
, char **remote_argv
, int remote_argc
,
336 int *f_in_p
, int *f_out_p
)
339 char *args
[MAX_ARGS
];
343 if (!read_batch
&& !local_server
) {
344 char *t
, *f
, in_quote
= '\0';
345 char *rsh_env
= getenv(RSYNC_RSH_ENV
);
350 cmd
= strdup(cmd
); /* MEMORY LEAK */
354 for (t
= f
= cmd
; *f
; f
++) {
357 /* Comparison leaves rooms for server_options(). */
358 if (argc
>= MAX_ARGS
- MAX_SERVER_ARGS
)
361 while (*f
!= ' ' || in_quote
) {
365 "Missing trailing-%c in remote-shell command.\n",
367 exit_cleanup(RERR_SYNTAX
);
372 if (*f
== '\'' || *f
== '"') {
377 if (*f
== in_quote
&& *++f
!= in_quote
) {
387 /* check to see if we've already been given '-l user' in
388 * the remote-shell command */
389 for (i
= 0; i
< argc
-1; i
++) {
390 if (!strcmp(args
[i
], "-l") && args
[i
+1][0] != '-')
395 /* remsh (on HPUX) takes the arguments the other way around */
396 args
[argc
++] = machine
;
397 if (user
&& !(daemon_over_rsh
&& dash_l_set
)) {
402 if (user
&& !(daemon_over_rsh
&& dash_l_set
)) {
406 args
[argc
++] = machine
;
409 args
[argc
++] = rsync_path
;
411 if (blocking_io
< 0) {
413 if ((cp
= strrchr(cmd
, '/')) != NULL
)
417 if (strcmp(cp
, "rsh") == 0 || strcmp(cp
, "remsh") == 0)
421 server_options(args
,&argc
);
423 if (argc
>= MAX_ARGS
- 2)
429 if (!daemon_over_rsh
) {
430 while (remote_argc
> 0) {
431 if (argc
>= MAX_ARGS
- 1) {
433 rprintf(FERROR
, "internal: args[] overflowed in do_cmd()\n");
434 exit_cleanup(RERR_SYNTAX
);
436 args
[argc
++] = *remote_argv
++;
443 if (DEBUG_GTE(CMD
, 2)) {
444 for (i
= 0; i
< argc
; i
++)
445 rprintf(FCLIENT
, "cmd[%d]=%s ", i
, args
[i
]);
446 rprintf(FCLIENT
, "\n");
450 int from_gen_pipe
[2];
451 set_allow_inc_recurse();
452 if (fd_pair(from_gen_pipe
) < 0) {
453 rsyserr(FERROR
, errno
, "pipe");
454 exit_cleanup(RERR_IPC
);
456 batch_gen_fd
= from_gen_pipe
[0];
457 *f_out_p
= from_gen_pipe
[1];
459 pid
= (pid_t
)-1; /* no child pid */
463 } else if (local_server
) {
464 /* If the user didn't request --[no-]whole-file, force
465 * it on, but only if we're not batch processing. */
466 if (whole_file
< 0 && !write_batch
)
468 set_allow_inc_recurse();
469 pid
= local_child(argc
, args
, f_in_p
, f_out_p
, child_main
);
474 pid
= piped_child(args
, f_in_p
, f_out_p
);
479 send_protected_args(*f_out_p
, args
);
485 out_of_memory("do_cmd");
486 return 0; /* not reached */
489 /* The receiving side operates in one of two modes:
491 * 1. it receives any number of files into a destination directory,
492 * placing them according to their names in the file-list.
494 * 2. it receives a single file and saves it using the name in the
495 * destination path instead of its file-list name. This requires a
496 * "local name" for writing out the destination file.
498 * So, our task is to figure out what mode/local-name we need.
499 * For mode 1, we change into the destination directory and return NULL.
500 * For mode 2, we change into the directory containing the destination
501 * file (if we aren't already there) and return the local-name. */
502 static char *get_local_name(struct file_list
*flist
, char *dest_path
)
508 if (DEBUG_GTE(RECV
, 1)) {
509 rprintf(FINFO
, "get_local_name count=%d %s\n",
510 file_total
, NS(dest_path
));
513 if (!dest_path
|| list_only
)
516 if (daemon_filter_list
.head
) {
517 char *slash
= strrchr(dest_path
, '/');
518 if (slash
&& (slash
[1] == '\0' || (slash
[1] == '.' && slash
[2] == '\0')))
522 if ((*dest_path
!= '.' || dest_path
[1] != '\0')
523 && (check_filter(&daemon_filter_list
, FLOG
, dest_path
, 0) < 0
524 || check_filter(&daemon_filter_list
, FLOG
, dest_path
, 1) < 0)) {
525 rprintf(FERROR
, "skipping daemon-excluded destination \"%s\"\n",
527 exit_cleanup(RERR_FILESELECT
);
533 /* See what currently exists at the destination. */
534 if ((statret
= do_stat(dest_path
, &st
)) == 0) {
535 /* If the destination is a dir, enter it and use mode 1. */
536 if (S_ISDIR(st
.st_mode
)) {
537 if (!change_dir(dest_path
, CD_NORMAL
)) {
538 rsyserr(FERROR
, errno
, "change_dir#1 %s failed",
539 full_fname(dest_path
));
540 exit_cleanup(RERR_FILESELECT
);
544 if (file_total
> 1) {
546 "ERROR: destination must be a directory when"
547 " copying more than 1 file\n");
548 exit_cleanup(RERR_FILESELECT
);
550 if (file_total
== 1 && S_ISDIR(flist
->files
[0]->mode
)) {
552 "ERROR: cannot overwrite non-directory"
553 " with a directory\n");
554 exit_cleanup(RERR_FILESELECT
);
556 } else if (errno
!= ENOENT
) {
557 /* If we don't know what's at the destination, fail. */
558 rsyserr(FERROR
, errno
, "ERROR: cannot stat destination %s",
559 full_fname(dest_path
));
560 exit_cleanup(RERR_FILESELECT
);
563 cp
= strrchr(dest_path
, '/');
565 /* If we need a destination directory because the transfer is not
566 * of a single non-directory or the user has requested one via a
567 * destination path ending in a slash, create one and use mode 1. */
568 if (file_total
> 1 || (cp
&& !cp
[1])) {
569 /* Lop off the final slash (if any). */
575 "ERROR: destination path is not a directory\n");
576 exit_cleanup(RERR_SYNTAX
);
579 if (mkdir_defmode(dest_path
) != 0) {
580 rsyserr(FERROR
, errno
, "mkdir %s failed",
581 full_fname(dest_path
));
582 exit_cleanup(RERR_FILEIO
);
585 if (flist
->high
>= flist
->low
586 && strcmp(flist
->files
[flist
->low
]->basename
, ".") == 0)
587 flist
->files
[0]->flags
|= FLAG_DIR_CREATED
;
589 if (INFO_GTE(NAME
, 1))
590 rprintf(FINFO
, "created directory %s\n", dest_path
);
593 /* Indicate that dest dir doesn't really exist. */
597 if (!change_dir(dest_path
, dry_run
> 1 ? CD_SKIP_CHDIR
: CD_NORMAL
)) {
598 rsyserr(FERROR
, errno
, "change_dir#2 %s failed",
599 full_fname(dest_path
));
600 exit_cleanup(RERR_FILESELECT
);
606 /* Otherwise, we are writing a single file, possibly on top of an
607 * existing non-directory. Change to the item's parent directory
608 * (if it has a path component), return the basename of the
609 * destination file as the local name, and use mode 2. */
617 if (!change_dir(dest_path
, CD_NORMAL
)) {
618 rsyserr(FERROR
, errno
, "change_dir#3 %s failed",
619 full_fname(dest_path
));
620 exit_cleanup(RERR_FILESELECT
);
627 /* This function checks on our alternate-basis directories. If we're in
628 * dry-run mode and the destination dir does not yet exist, we'll try to
629 * tweak any dest-relative paths to make them work for a dry-run (the
630 * destination dir must be in curr_dir[] when this function is called).
631 * We also warn about any arg that is non-existent or not a directory. */
632 static void check_alt_basis_dirs(void)
635 char **dir_p
, *slash
= strrchr(curr_dir
, '/');
637 for (dir_p
= basis_dir
; *dir_p
; dir_p
++) {
638 if (dry_run
> 1 && **dir_p
!= '/') {
639 int len
= curr_dir_len
+ 1 + strlen(*dir_p
) + 1;
640 char *new = new_array(char, len
);
642 out_of_memory("check_alt_basis_dirs");
643 if (slash
&& strncmp(*dir_p
, "../", 3) == 0) {
644 /* We want to remove only one leading "../" prefix for
645 * the directory we couldn't create in dry-run mode:
646 * this ensures that any other ".." references get
647 * evaluated the same as they would for a live copy. */
649 pathjoin(new, len
, curr_dir
, *dir_p
+ 3);
652 pathjoin(new, len
, curr_dir
, *dir_p
);
655 if (do_stat(*dir_p
, &st
) < 0) {
656 rprintf(FWARNING
, "%s arg does not exist: %s\n",
657 dest_option
, *dir_p
);
658 } else if (!S_ISDIR(st
.st_mode
)) {
659 rprintf(FWARNING
, "%s arg is not a dir: %s\n",
660 dest_option
, *dir_p
);
665 /* This is only called by the sender. */
666 static void read_final_goodbye(int f_in
)
670 char xname
[MAXPATHLEN
];
672 if (protocol_version
< 29)
675 i
= read_ndx_and_attrs(f_in
, &iflags
, &fnamecmp_type
,
680 rprintf(FERROR
, "Invalid packet at end of run (%d) [%s]\n",
682 exit_cleanup(RERR_PROTOCOL
);
686 static void do_server_sender(int f_in
, int f_out
, int argc
, char *argv
[])
688 struct file_list
*flist
;
691 if (DEBUG_GTE(SEND
, 1)) {
692 rprintf(FINFO
, "server_sender starting pid=%ld\n",
696 if (am_daemon
&& lp_write_only(module_id
)) {
697 rprintf(FERROR
, "ERROR: module is write only\n");
698 exit_cleanup(RERR_SYNTAX
);
701 if (am_daemon
&& lp_read_only(module_id
) && remove_source_files
) {
703 "ERROR: --remove-%s-files cannot be used with a read-only module\n",
704 remove_source_files
== 1 ? "source" : "sent");
705 exit_cleanup(RERR_SYNTAX
);
709 if (!relative_paths
) {
710 if (!change_dir(dir
, CD_NORMAL
)) {
711 rsyserr(FERROR
, errno
, "change_dir#3 %s failed",
713 exit_cleanup(RERR_FILESELECT
);
719 if (argc
== 0 && (recurse
|| xfer_dirs
|| list_only
)) {
725 flist
= send_file_list(f_out
,argc
,argv
);
726 if (!flist
|| flist
->used
== 0)
729 io_start_buffering_in(f_in
);
731 send_files(f_in
, f_out
);
732 io_flush(FULL_FLUSH
);
734 if (protocol_version
>= 24)
735 read_final_goodbye(f_in
);
736 io_flush(FULL_FLUSH
);
741 static int do_recv(int f_in
, int f_out
, char *local_name
)
747 /* The receiving side mustn't obey this, or an existing symlink that
748 * points to an identical file won't be replaced by the referent. */
749 copy_links
= copy_dirlinks
= copy_unsafe_links
= 0;
751 #ifdef SUPPORT_HARD_LINKS
752 if (preserve_hard_links
&& !inc_recurse
)
753 match_hard_links(first_flist
);
756 if (fd_pair(error_pipe
) < 0) {
757 rsyserr(FERROR
, errno
, "pipe failed in do_recv");
758 exit_cleanup(RERR_IPC
);
761 io_flush(NORMAL_FLUSH
);
763 if ((pid
= do_fork()) == -1) {
764 rsyserr(FERROR
, errno
, "fork failed in do_recv");
765 exit_cleanup(RERR_IPC
);
769 close(error_pipe
[0]);
773 /* we can't let two processes write to the socket at one time */
774 io_end_multiplex_out();
776 /* set place to send errors */
777 set_msg_fd_out(error_pipe
[1]);
778 io_start_buffering_out(error_pipe
[1]);
780 recv_files(f_in
, local_name
);
781 io_flush(FULL_FLUSH
);
784 if (output_needs_newline
) {
786 output_needs_newline
= 0;
789 send_msg(MSG_DONE
, "", 1, 0);
790 write_varlong(error_pipe
[1], stats
.total_read
, 3);
791 io_flush(FULL_FLUSH
);
793 /* Handle any keep-alive packets from the post-processing work
794 * that the generator does. */
795 if (protocol_version
>= 29) {
798 char xname
[MAXPATHLEN
];
800 kluge_around_eof
= -1;
802 /* This should only get stopped via a USR2 signal. */
803 read_ndx_and_attrs(f_in
, &iflags
, &fnamecmp_type
,
806 rprintf(FERROR
, "Invalid packet at end of run [%s]\n",
808 exit_cleanup(RERR_PROTOCOL
);
811 /* Finally, we go to sleep until our parent kills us with a
812 * USR2 signal. We sleep for a short time, as on some OSes
813 * a signal won't interrupt a sleep! */
820 io_end_multiplex_in();
821 if (write_batch
&& !am_server
)
824 close(error_pipe
[1]);
828 io_start_buffering_out(f_out
);
830 set_msg_fd_in(error_pipe
[0]);
831 io_start_buffering_in(error_pipe
[0]);
833 #ifdef SUPPORT_HARD_LINKS
834 if (preserve_hard_links
&& inc_recurse
) {
835 struct file_list
*flist
;
836 for (flist
= first_flist
; flist
; flist
= flist
->next
)
837 match_hard_links(flist
);
841 generate_files(f_out
, local_name
);
844 io_flush(FULL_FLUSH
);
845 if (protocol_version
>= 24) {
846 /* send a final goodbye message */
847 write_ndx(f_out
, NDX_DONE
);
849 io_flush(FULL_FLUSH
);
853 wait_process_with_flush(pid
, &exit_code
);
857 static void do_server_recv(int f_in
, int f_out
, int argc
, char *argv
[])
860 struct file_list
*flist
;
861 char *local_name
= NULL
;
864 if (filesfrom_fd
>= 0 && !msgs2stderr
) {
865 /* We can't mix messages with files-from data on the socket,
866 * so temporarily turn off info/debug messages. */
867 negate_output_levels();
872 if (DEBUG_GTE(RECV
, 1)) {
873 rprintf(FINFO
, "server_recv(%d) starting pid=%ld\n",
874 argc
, (long)getpid());
877 if (am_daemon
&& lp_read_only(module_id
)) {
878 rprintf(FERROR
,"ERROR: module is read only\n");
879 exit_cleanup(RERR_SYNTAX
);
887 if (!am_daemon
&& !change_dir(dir
, CD_NORMAL
)) {
888 rsyserr(FERROR
, errno
, "change_dir#4 %s failed",
890 exit_cleanup(RERR_FILESELECT
);
894 if (protocol_version
>= 30)
895 io_start_multiplex_in();
897 io_start_buffering_in(f_in
);
898 recv_filter_list(f_in
);
900 if (filesfrom_fd
>= 0) {
901 /* We need to send the files-from names to the sender at the
902 * same time that we receive the file-list from them, so we
903 * need the IO routines to automatically write out the names
904 * onto our f_out socket as we read the file-list. This
905 * avoids both deadlock and extra delays/buffers. */
906 io_set_filesfrom_fds(filesfrom_fd
, f_out
);
910 flist
= recv_file_list(f_in
);
912 rprintf(FERROR
,"server_recv: recv_file_list error\n");
913 exit_cleanup(RERR_FILESELECT
);
915 if (inc_recurse
&& file_total
== 1)
916 recv_additional_file_list(f_in
);
919 negate_output_levels();
922 local_name
= get_local_name(flist
,argv
[0]);
924 /* Now that we know what our destination directory turned out to be,
925 * we can sanitize the --link-/copy-/compare-dest args correctly. */
926 if (sanitize_paths
) {
928 for (dir_p
= basis_dir
; *dir_p
; dir_p
++)
929 *dir_p
= sanitize_path(NULL
, *dir_p
, NULL
, curr_dir_depth
, SP_DEFAULT
);
931 partial_dir
= sanitize_path(NULL
, partial_dir
, NULL
, curr_dir_depth
, SP_DEFAULT
);
933 check_alt_basis_dirs();
935 if (daemon_filter_list
.head
) {
937 struct filter_list_struct
*elp
= &daemon_filter_list
;
939 for (dir_p
= basis_dir
; *dir_p
; dir_p
++) {
942 dir
+= module_dirlen
;
943 if (check_filter(elp
, FLOG
, dir
, 1) < 0)
944 goto options_rejected
;
946 if (partial_dir
&& *partial_dir
== '/'
947 && check_filter(elp
, FLOG
, partial_dir
+ module_dirlen
, 1) < 0) {
950 "Your options have been rejected by the server.\n");
951 exit_cleanup(RERR_SYNTAX
);
955 exit_code
= do_recv(f_in
, f_out
, local_name
);
956 exit_cleanup(exit_code
);
960 int child_main(int argc
, char *argv
[])
962 start_server(STDIN_FILENO
, STDOUT_FILENO
, argc
, argv
);
967 void start_server(int f_in
, int f_out
, int argc
, char *argv
[])
969 set_nonblocking(f_in
);
970 set_nonblocking(f_out
);
972 io_set_sock_fds(f_in
, f_out
);
973 setup_protocol(f_out
, f_in
);
975 if (protocol_version
>= 23)
976 io_start_multiplex_out();
979 keep_dirlinks
= 0; /* Must be disabled on the sender. */
980 if (need_messages_from_generator
)
981 io_start_multiplex_in();
982 recv_filter_list(f_in
);
983 do_server_sender(f_in
, f_out
, argc
, argv
);
985 do_server_recv(f_in
, f_out
, argc
, argv
);
991 * This is called once the connection has been negotiated. It is used
992 * for rsyncd, remote-shell, and local connections.
994 int client_run(int f_in
, int f_out
, pid_t pid
, int argc
, char *argv
[])
996 struct file_list
*flist
= NULL
;
997 int exit_code
= 0, exit_code2
= 0;
998 char *local_name
= NULL
;
1000 cleanup_child_pid
= pid
;
1002 set_nonblocking(f_in
);
1003 set_nonblocking(f_out
);
1006 io_set_sock_fds(f_in
, f_out
);
1007 setup_protocol(f_out
,f_in
);
1009 /* We set our stderr file handle to blocking because ssh might have
1010 * set it to non-blocking. This can be particularly troublesome if
1011 * stderr is a clone of stdout, because ssh would have set our stdout
1012 * to non-blocking at the same time (which can easily cause us to lose
1013 * output from our print statements). This kluge shouldn't cause ssh
1014 * any problems for how we use it. Note also that we delayed setting
1015 * this until after the above protocol setup so that we know for sure
1016 * that ssh is done twiddling its file descriptors. */
1017 set_blocking(STDERR_FILENO
);
1020 keep_dirlinks
= 0; /* Must be disabled on the sender. */
1023 && (log_format_has(stdout_format
, 'C')
1024 || log_format_has(logfile_format
, 'C')))
1025 sender_keeps_checksum
= 1;
1027 if (protocol_version
>= 30)
1028 io_start_multiplex_out();
1030 io_start_buffering_out(f_out
);
1031 if (!filesfrom_host
)
1032 set_msg_fd_in(f_in
);
1033 send_filter_list(f_out
);
1035 filesfrom_fd
= f_in
;
1037 if (write_batch
&& !am_server
)
1038 start_write_batch(f_out
);
1039 flist
= send_file_list(f_out
, argc
, argv
);
1041 if (DEBUG_GTE(FLIST
, 3))
1042 rprintf(FINFO
,"file list sent\n");
1044 if (protocol_version
>= 23)
1045 io_start_multiplex_in();
1047 io_flush(NORMAL_FLUSH
);
1048 send_files(f_in
, f_out
);
1049 io_flush(FULL_FLUSH
);
1051 if (protocol_version
>= 24)
1052 read_final_goodbye(f_in
);
1054 if (DEBUG_GTE(EXIT
, 2))
1055 rprintf(FINFO
,"client_run waiting on %d\n", (int) pid
);
1056 io_flush(FULL_FLUSH
);
1057 wait_process_with_flush(pid
, &exit_code
);
1060 io_flush(FULL_FLUSH
);
1061 exit_cleanup(exit_code
);
1065 if (protocol_version
>= 23)
1066 io_start_multiplex_in();
1067 if (need_messages_from_generator
)
1068 io_start_multiplex_out();
1071 send_filter_list(read_batch
? -1 : f_out
);
1073 if (filesfrom_fd
>= 0) {
1074 io_set_filesfrom_fds(filesfrom_fd
, f_out
);
1078 if (write_batch
&& !am_server
)
1079 start_write_batch(f_in
);
1080 flist
= recv_file_list(f_in
);
1081 if (inc_recurse
&& file_total
== 1)
1082 recv_additional_file_list(f_in
);
1084 if (flist
&& flist
->used
> 0) {
1085 local_name
= get_local_name(flist
, argv
[0]);
1087 check_alt_basis_dirs();
1089 exit_code2
= do_recv(f_in
, f_out
, local_name
);
1096 if (DEBUG_GTE(RECV
, 1))
1097 rprintf(FINFO
,"client_run2 waiting on %d\n", (int) pid
);
1098 io_flush(FULL_FLUSH
);
1099 wait_process_with_flush(pid
, &exit_code
);
1102 return MAX(exit_code
, exit_code2
);
1105 static int copy_argv(char *argv
[])
1109 for (i
= 0; argv
[i
]; i
++) {
1110 if (!(argv
[i
] = strdup(argv
[i
]))) {
1111 rprintf (FERROR
, "out of memory at %s(%d)\n",
1112 __FILE__
, __LINE__
);
1122 * Start a client for either type of remote connection. Work out
1123 * whether the arguments request a remote shell or rsyncd connection,
1124 * and call the appropriate connection function, then run_client.
1126 * Calls either start_socket_client (for sockets) or do_cmd and
1127 * client_run (for ssh).
1129 static int start_client(int argc
, char *argv
[])
1131 char *p
, *shell_machine
= NULL
, *shell_user
= NULL
;
1138 /* Don't clobber argv[] so that ps(1) can still show the right
1140 if ((ret
= copy_argv(argv
)) != 0)
1143 if (!read_batch
) { /* for read_batch, NO source is specified */
1144 char *path
= check_for_hostspec(argv
[0], &shell_machine
, &rsync_port
);
1145 if (path
) { /* source is remote */
1152 if (argc
== 1 || **argv
== ':')
1153 argc
= 0; /* no dest arg */
1154 else if (check_for_hostspec(*argv
, &dummy_host
, &dummy_port
)) {
1156 "The source and destination cannot both be remote.\n");
1157 exit_cleanup(RERR_SYNTAX
);
1159 remote_argc
--; /* don't count dest */
1162 if (filesfrom_host
&& *filesfrom_host
1163 && strcmp(filesfrom_host
, shell_machine
) != 0) {
1165 "--files-from hostname is not the same as the transfer hostname\n");
1166 exit_cleanup(RERR_SYNTAX
);
1170 daemon_over_rsh
= shell_cmd
? 1 : -1;
1171 } else { /* source is local, check dest arg */
1176 remote_argv
= argv
+ argc
;
1178 static char *dotarg
[1] = { "." };
1180 remote_argv
= dotarg
;
1184 path
= check_for_hostspec(p
, &shell_machine
, &rsync_port
);
1185 if (path
&& filesfrom_host
&& *filesfrom_host
1186 && strcmp(filesfrom_host
, shell_machine
) != 0) {
1188 "--files-from hostname is not the same as the transfer hostname\n");
1189 exit_cleanup(RERR_SYNTAX
);
1191 if (!path
) { /* no hostspec found, so src & dest are local */
1193 if (filesfrom_host
) {
1195 "--files-from cannot be remote when the transfer is local\n");
1196 exit_cleanup(RERR_SYNTAX
);
1198 shell_machine
= NULL
;
1199 } else { /* hostspec was found, so dest is remote */
1202 daemon_over_rsh
= shell_cmd
? 1 : -1;
1205 } else { /* read_batch */
1207 if (check_for_hostspec(argv
[argc
-1], &shell_machine
, &rsync_port
)) {
1208 rprintf(FERROR
, "remote destination is not allowed with --read-batch\n");
1209 exit_cleanup(RERR_SYNTAX
);
1211 remote_argv
= argv
+ argc
- 1;
1217 int dummy_port
= rsync_port
;
1219 /* For local source, extra source args must not have hostspec. */
1220 for (i
= 1; i
< argc
; i
++) {
1221 if (check_for_hostspec(argv
[i
], &dummy_host
, &dummy_port
)) {
1222 rprintf(FERROR
, "Unexpected remote arg: %s\n", argv
[i
]);
1223 exit_cleanup(RERR_SYNTAX
);
1228 int dummy_port
= rsync_port
;
1230 /* For remote source, any extra source args must have either
1231 * the same hostname or an empty hostname. */
1232 for (i
= 1; i
< remote_argc
; i
++) {
1233 char *arg
= check_for_hostspec(remote_argv
[i
], &dummy_host
, &dummy_port
);
1235 rprintf(FERROR
, "Unexpected local arg: %s\n", remote_argv
[i
]);
1236 rprintf(FERROR
, "If arg is a remote file/dir, prefix it with a colon (:).\n");
1237 exit_cleanup(RERR_SYNTAX
);
1239 if (*dummy_host
&& strcmp(dummy_host
, shell_machine
) != 0) {
1240 rprintf(FERROR
, "All source args must come from the same machine.\n");
1241 exit_cleanup(RERR_SYNTAX
);
1243 if (rsync_port
!= dummy_port
) {
1244 if (!rsync_port
|| !dummy_port
)
1245 rprintf(FERROR
, "All source args must use the same hostspec format.\n");
1247 rprintf(FERROR
, "All source args must use the same port number.\n");
1248 exit_cleanup(RERR_SYNTAX
);
1250 remote_argv
[i
] = arg
;
1254 if (daemon_over_rsh
< 0)
1255 return start_socket_client(shell_machine
, remote_argc
, remote_argv
, argc
, argv
);
1257 if (password_file
&& !daemon_over_rsh
) {
1258 rprintf(FERROR
, "The --password-file option may only be "
1259 "used when accessing an rsync daemon.\n");
1260 exit_cleanup(RERR_SYNTAX
);
1263 if (connect_timeout
) {
1264 rprintf(FERROR
, "The --contimeout option may only be "
1265 "used when connecting to an rsync daemon.\n");
1266 exit_cleanup(RERR_SYNTAX
);
1269 if (shell_machine
) {
1270 p
= strrchr(shell_machine
,'@');
1273 shell_user
= shell_machine
;
1274 shell_machine
= p
+1;
1278 if (DEBUG_GTE(CMD
, 2)) {
1279 rprintf(FINFO
,"cmd=%s machine=%s user=%s path=%s\n",
1280 NS(shell_cmd
), NS(shell_machine
), NS(shell_user
),
1281 remote_argv
? NS(remote_argv
[0]) : "");
1284 pid
= do_cmd(shell_cmd
, shell_machine
, shell_user
, remote_argv
, remote_argc
,
1287 /* if we're running an rsync server on the remote host over a
1288 * remote shell command, we need to do the RSYNCD protocol first */
1289 if (daemon_over_rsh
) {
1291 tmpret
= start_inband_exchange(f_in
, f_out
, shell_user
, remote_argc
, remote_argv
);
1296 ret
= client_run(f_in
, f_out
, pid
, argc
, argv
);
1305 static RETSIGTYPE
sigusr1_handler(UNUSED(int val
))
1307 exit_cleanup(RERR_SIGNAL1
);
1310 static RETSIGTYPE
sigusr2_handler(UNUSED(int val
))
1316 _exit(RERR_PARTIAL
);
1320 RETSIGTYPE
remember_children(UNUSED(int val
))
1325 /* An empty waitpid() loop was put here by Tridge and we could never
1326 * get him to explain why he put it in, so rather than taking it
1327 * out we're instead saving the child exit statuses for later use.
1328 * The waitpid() loop presumably eliminates all possibility of leaving
1329 * zombie children, maybe that's why he did it. */
1330 while ((pid
= waitpid(-1, &status
, WNOHANG
)) > 0) {
1331 /* save the child's exit status */
1332 for (cnt
= 0; cnt
< MAXCHILDPROCS
; cnt
++) {
1333 if (pid_stat_table
[cnt
].pid
== 0) {
1334 pid_stat_table
[cnt
].pid
= pid
;
1335 pid_stat_table
[cnt
].status
= status
;
1341 #ifndef HAVE_SIGACTION
1342 signal(SIGCHLD
, remember_children
);
1348 * This routine catches signals and tries to send them to gdb.
1350 * Because it's called from inside a signal handler it ought not to
1351 * use too many library routines.
1353 * @todo Perhaps use "screen -X" instead/as well, to help people
1354 * debugging without easy access to X. Perhaps use an environment
1355 * variable, or just call a script?
1357 * @todo The /proc/ magic probably only works on Linux (and
1358 * Solaris?) Can we be more portable?
1360 #ifdef MAINTAINER_MODE
1361 const char *get_panic_action(void)
1363 const char *cmd_fmt
= getenv("RSYNC_PANIC_ACTION");
1368 return "xterm -display :0 -T Panic -n Panic "
1369 "-e gdb /proc/%d/exe %d";
1374 * Handle a fatal signal by launching a debugger, controlled by $RSYNC_PANIC_ACTION.
1376 * This signal handler is only installed if we were configured with
1377 * --enable-maintainer-mode. Perhaps it should always be on and we
1378 * should just look at the environment variable, but I'm a bit leery
1379 * of a signal sending us into a busy loop.
1381 static RETSIGTYPE
rsync_panic_handler(UNUSED(int whatsig
))
1386 snprintf(cmd_buf
, sizeof cmd_buf
, get_panic_action(),
1387 getpid(), getpid());
1389 /* Unless we failed to execute gdb, we allow the process to
1390 * continue. I'm not sure if that's right. */
1391 ret
= system(cmd_buf
);
1398 int main(int argc
,char *argv
[])
1401 int orig_argc
= argc
;
1402 char **orig_argv
= argv
;
1403 #ifdef HAVE_SIGACTION
1404 # ifdef HAVE_SIGPROCMASK
1407 sigemptyset(&sigmask
);
1409 sigact
.sa_flags
= SA_NOCLDSTOP
;
1411 SIGACTMASK(SIGUSR1
, sigusr1_handler
);
1412 SIGACTMASK(SIGUSR2
, sigusr2_handler
);
1413 SIGACTMASK(SIGCHLD
, remember_children
);
1414 #ifdef MAINTAINER_MODE
1415 SIGACTMASK(SIGSEGV
, rsync_panic_handler
);
1416 SIGACTMASK(SIGFPE
, rsync_panic_handler
);
1417 SIGACTMASK(SIGABRT
, rsync_panic_handler
);
1418 SIGACTMASK(SIGBUS
, rsync_panic_handler
);
1421 starttime
= time(NULL
);
1423 am_root
= our_uid
== 0;
1425 memset(&stats
, 0, sizeof(stats
));
1429 exit_cleanup(RERR_SYNTAX
);
1432 /* we set a 0 umask so that correct file permissions can be
1434 orig_umask
= umask(0);
1436 #if defined CONFIG_LOCALE && defined HAVE_SETLOCALE
1437 setlocale(LC_CTYPE
, "");
1440 if (!parse_arguments(&argc
, (const char ***) &argv
)) {
1441 /* FIXME: We ought to call the same error-handling
1442 * code here, rather than relying on getopt. */
1444 exit_cleanup(RERR_SYNTAX
);
1447 SIGACTMASK(SIGINT
, sig_int
);
1448 SIGACTMASK(SIGHUP
, sig_int
);
1449 SIGACTMASK(SIGTERM
, sig_int
);
1450 #if defined HAVE_SIGACTION && HAVE_SIGPROCMASK
1451 sigprocmask(SIG_UNBLOCK
, &sigmask
, NULL
);
1454 /* Ignore SIGPIPE; we consistently check error codes and will
1456 SIGACTION(SIGPIPE
, SIG_IGN
);
1458 SIGACTION(SIGXFSZ
, SIG_IGN
);
1461 /* Initialize change_dir() here because on some old systems getcwd
1462 * (implemented by forking "pwd" and reading its output) doesn't
1463 * work when there are other child processes. Also, on all systems
1464 * that implement getcwd that way "pwd" can't be found after chroot. */
1465 change_dir(NULL
, CD_NORMAL
);
1469 if ((write_batch
|| read_batch
) && !am_server
) {
1471 write_batch_shell_file(orig_argc
, orig_argv
, argc
);
1473 if (read_batch
&& strcmp(batch_name
, "-") == 0)
1474 batch_fd
= STDIN_FILENO
;
1476 batch_fd
= do_open(batch_name
,
1477 write_batch
? O_WRONLY
| O_CREAT
| O_TRUNC
1478 : O_RDONLY
, S_IRUSR
| S_IWUSR
);
1481 rsyserr(FERROR
, errno
, "Batch file %s open error",
1482 full_fname(batch_name
));
1483 exit_cleanup(RERR_FILEIO
);
1486 read_stream_flags(batch_fd
);
1488 write_stream_flags(batch_fd
);
1490 if (write_batch
< 0)
1497 } else if (am_daemon
)
1498 return daemon_main();
1500 if (am_server
&& protect_args
) {
1501 char buf
[MAXPATHLEN
];
1503 read_args(STDIN_FILENO
, NULL
, buf
, sizeof buf
, 1, &argv
, &argc
, NULL
);
1504 if (!parse_arguments(&argc
, (const char ***) &argv
)) {
1506 exit_cleanup(RERR_SYNTAX
);
1512 exit_cleanup(RERR_SYNTAX
);
1516 set_nonblocking(STDIN_FILENO
);
1517 set_nonblocking(STDOUT_FILENO
);
1519 return start_daemon(STDIN_FILENO
, STDOUT_FILENO
);
1520 start_server(STDIN_FILENO
, STDOUT_FILENO
, argc
, argv
);
1523 ret
= start_client(argc
, argv
);
1525 exit_cleanup(RERR_STARTCLIENT
);