- Use the new *_CONTENT_DIR flag names (was *_XFER_DIR).
[rsync/rsync.git] / main.c
CommitLineData
0f78b815
WD
1/*
2 * The startup routines, including main(), for rsync.
3 *
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>
ba2133d6 7 * Copyright (C) 2003-2007 Wayne Davison
0f78b815
WD
8 *
9 * This program is free software; you can redistribute it and/or modify
8e41b68e
WD
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.
0f78b815
WD
13 *
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.
18 *
e7c67065 19 * You should have received a copy of the GNU General Public License along
4fd842f9 20 * with this program; if not, visit the http://fsf.org website.
0f78b815 21 */
c627d613
AT
22
23#include "rsync.h"
1b42f628 24#include "ifuncs.h"
a72ba0cf 25#include "io.h"
d9401514
WD
26#if defined CONFIG_LOCALE && defined HAVE_LOCALE_H
27#include <locale.h>
28#endif
c627d613 29
50839b4b
WD
30extern int verbose;
31extern int dry_run;
32extern int list_only;
32eda096 33extern int am_root;
d9c7edf6
WD
34extern int am_server;
35extern int am_sender;
b695f242 36extern int am_generator;
d9c7edf6 37extern int am_daemon;
3ea6e0e7 38extern int inc_recurse;
32eda096 39extern int blocking_io;
47c11975 40extern int remove_source_files;
bf26aa22 41extern int need_messages_from_generator;
051182cb 42extern int kluge_around_eof;
32eda096 43extern int do_stats;
32eda096
WD
44extern int log_got_error;
45extern int module_id;
bb6721dc 46extern int copy_links;
a695b379 47extern int copy_dirlinks;
83926d3c 48extern int keep_dirlinks;
32eda096 49extern int preserve_hard_links;
d04e9c51 50extern int protocol_version;
f3d6d480 51extern int file_total;
32eda096 52extern int recurse;
26bbb6aa 53extern int xfer_dirs;
f7e5068d 54extern int protect_args;
32eda096 55extern int relative_paths;
7c58c991 56extern int sanitize_paths;
c2a2147a 57extern int curr_dir_depth;
615a5415 58extern int curr_dir_len;
7c58c991 59extern int module_id;
32eda096 60extern int rsync_port;
b1df18d7 61extern int whole_file;
32eda096
WD
62extern int read_batch;
63extern int write_batch;
b9f592fb 64extern int batch_fd;
32eda096
WD
65extern int filesfrom_fd;
66extern pid_t cleanup_child_pid;
50839b4b 67extern struct stats stats;
860236bf 68extern char *filesfrom_host;
c2c8db91 69extern char *partial_dir;
7c58c991 70extern char *basis_dir[];
32eda096
WD
71extern char *rsync_path;
72extern char *shell_cmd;
9b3318b0 73extern char *batch_name;
a39da29a 74extern char *password_file;
615a5415 75extern char curr_dir[MAXPATHLEN];
da131912 76extern struct file_list *first_flist;
c2c8db91 77extern struct filter_list_struct server_filter_list;
71605b0f
WD
78#ifdef ICONV_OPTION
79extern iconv_t ic_send;
80#endif
57dee64e
WD
81
82int local_server = 0;
e208631a 83int daemon_over_rsh = 0;
05278935 84mode_t orig_umask = 0;
f3d6d480 85int batch_gen_fd = -1;
c627d613 86
91c5833b
WD
87/* There's probably never more than at most 2 outstanding child processes,
88 * but set it higher, just in case. */
84e6d6fd 89#define MAXCHILDPROCS 7
ee7118a8 90
8261af74
WD
91#ifdef HAVE_SIGACTION
92# ifdef HAVE_SIGPROCMASK
93# define SIGACTMASK(n,h) SIGACTION(n,h), sigaddset(&sigmask,(n))
94# else
95# define SIGACTMASK(n,h) SIGACTION(n,h)
96# endif
60ee01f5
WD
97static struct sigaction sigact;
98#endif
99
ee7118a8
DD
100struct pid_status {
101 pid_t pid;
84e6d6fd 102 int status;
ee7118a8
DD
103} pid_stat_table[MAXCHILDPROCS];
104
33c4b445
WD
105static time_t starttime, endtime;
106static int64 total_read, total_written;
107
e5a2b854 108static void show_malloc_stats(void);
82980a23 109
97d8e709 110/* Works like waitpid(), but if we already harvested the child pid in our
6d59ac19 111 * remember_children(), we succeed instead of returning an error. */
97d8e709 112pid_t wait_process(pid_t pid, int *status_ptr, int flags)
82980a23 113{
d365e229
WD
114 pid_t waited_pid;
115
116 do {
117 waited_pid = waitpid(pid, status_ptr, flags);
118 } while (waited_pid == -1 && errno == EINTR);
d9c7edf6 119
6fb812f7 120 if (waited_pid == -1 && errno == ECHILD) {
97d8e709 121 /* Status of requested child no longer available: check to
6d59ac19 122 * see if it was processed by remember_children(). */
97d8e709 123 int cnt;
84e6d6fd 124 for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) {
ee7118a8 125 if (pid == pid_stat_table[cnt].pid) {
97d8e709 126 *status_ptr = pid_stat_table[cnt].status;
ee7118a8 127 pid_stat_table[cnt].pid = 0;
97d8e709 128 return pid;
ee7118a8
DD
129 }
130 }
131 }
132
97d8e709
WD
133 return waited_pid;
134}
135
136/* Wait for a process to exit, calling io_flush while waiting. */
84e6d6fd 137static void wait_process_with_flush(pid_t pid, int *exit_code_ptr)
97d8e709
WD
138{
139 pid_t waited_pid;
140 int status;
141
142 while ((waited_pid = wait_process(pid, &status, WNOHANG)) == 0) {
143 msleep(20);
144 io_flush(FULL_FLUSH);
145 }
146
d9c7edf6
WD
147 /* TODO: If the child exited on a signal, then log an
148 * appropriate error message. Perhaps we should also accept a
149 * message describing the purpose of the child. Also indicate
dbefb6b4 150 * this to the caller so that they know something went wrong. */
84e6d6fd
WD
151 if (waited_pid < 0) {
152 rsyserr(FERROR, errno, "waitpid");
153 *exit_code_ptr = RERR_WAITCHILD;
154 } else if (!WIFEXITED(status)) {
40e6752f 155#ifdef WCOREDUMP
dbefb6b4 156 if (WCOREDUMP(status))
84e6d6fd 157 *exit_code_ptr = RERR_CRASHED;
40e6752f
WD
158 else
159#endif
160 if (WIFSIGNALED(status))
84e6d6fd 161 *exit_code_ptr = RERR_TERMINATED;
dbefb6b4 162 else
84e6d6fd 163 *exit_code_ptr = RERR_WAITCHILD;
dbefb6b4 164 } else
84e6d6fd 165 *exit_code_ptr = WEXITSTATUS(status);
82980a23
AT
166}
167
b9f592fb
WD
168/* This function gets called from all 3 processes. We want the client side
169 * to actually output the text, but the sender is the only process that has
170 * all the stats we need. So, if we're a client sender, we do the report.
171 * If we're a server sender, we write the stats on the supplied fd. If
172 * we're the client receiver we read the stats from the supplied fd and do
173 * the report. All processes might also generate a set of debug stats, if
174 * the verbose level is high enough (this is the only thing that the
175 * generator process and the server receiver ever do here). */
33c4b445 176static void handle_stats(int f)
c627d613 177{
33c4b445
WD
178 endtime = time(NULL);
179
b9f592fb 180 /* Cache two stats because the read/write code can change it. */
33c4b445
WD
181 total_read = stats.total_read;
182 total_written = stats.total_written;
7a6421fa 183
7bb7058e 184 if (do_stats && verbose > 1) {
5c15e29f 185 /* These come out from every process */
7bb7058e 186 show_malloc_stats();
86943126 187 show_flist_stats();
5c15e29f
MP
188 }
189
e5fbaa71
S
190 if (am_generator)
191 return;
192
248fbb8c 193 if (am_daemon) {
83926d3c
WD
194 if (f == -1 || !am_sender)
195 return;
248fbb8c
AT
196 }
197
e19452a9 198 if (am_server) {
3e491682 199 if (am_sender) {
a72ba0cf
WD
200 write_varlong30(f, total_read, 3);
201 write_varlong30(f, total_written, 3);
202 write_varlong30(f, stats.total_size, 3);
f0f7e760 203 if (protocol_version >= 29) {
a72ba0cf
WD
204 write_varlong30(f, stats.flist_buildtime, 3);
205 write_varlong30(f, stats.flist_xfertime, 3);
f0f7e760 206 }
e19452a9 207 }
7a6421fa
AT
208 return;
209 }
e19452a9
DD
210
211 /* this is the client */
d9c7edf6 212
9d19f8a5 213 if (f < 0 && !am_sender) /* e.g. when we got an empty file list. */
0f78b815 214 ;
9d19f8a5 215 else if (!am_sender) {
58c5c245
WD
216 /* Read the first two in opposite order because the meaning of
217 * read/write swaps when switching from sender to receiver. */
a72ba0cf
WD
218 total_written = read_varlong30(f, 3);
219 total_read = read_varlong30(f, 3);
220 stats.total_size = read_varlong30(f, 3);
f0f7e760 221 if (protocol_version >= 29) {
a72ba0cf
WD
222 stats.flist_buildtime = read_varlong30(f, 3);
223 stats.flist_xfertime = read_varlong30(f, 3);
f0f7e760 224 }
e4676bb5 225 } else if (write_batch) {
b9f592fb
WD
226 /* The --read-batch process is going to be a client
227 * receiver, so we need to give it the stats. */
a72ba0cf
WD
228 write_varlong30(batch_fd, total_read, 3);
229 write_varlong30(batch_fd, total_written, 3);
230 write_varlong30(batch_fd, stats.total_size, 3);
f0f7e760 231 if (protocol_version >= 29) {
a72ba0cf
WD
232 write_varlong30(batch_fd, stats.flist_buildtime, 3);
233 write_varlong30(batch_fd, stats.flist_xfertime, 3);
f0f7e760 234 }
a800434a 235 }
e4676bb5 236}
a800434a 237
e4676bb5
WD
238static void output_summary(void)
239{
a800434a 240 if (do_stats) {
b64ee91a
WD
241 rprintf(FCLIENT, "\n");
242 rprintf(FINFO,"Number of files: %d\n", stats.num_files);
d9c7edf6
WD
243 rprintf(FINFO,"Number of files transferred: %d\n",
244 stats.num_transferred_files);
60613dc8
WD
245 rprintf(FINFO,"Total file size: %s bytes\n",
246 human_num(stats.total_size));
247 rprintf(FINFO,"Total transferred file size: %s bytes\n",
248 human_num(stats.total_transferred_size));
249 rprintf(FINFO,"Literal data: %s bytes\n",
250 human_num(stats.literal_data));
251 rprintf(FINFO,"Matched data: %s bytes\n",
252 human_num(stats.matched_data));
eb0144d7
WD
253 rprintf(FINFO,"File list size: %s\n",
254 human_num(stats.flist_size));
f0f7e760
WD
255 if (stats.flist_buildtime) {
256 rprintf(FINFO,
257 "File list generation time: %.3f seconds\n",
258 (double)stats.flist_buildtime / 1000);
259 rprintf(FINFO,
260 "File list transfer time: %.3f seconds\n",
261 (double)stats.flist_xfertime / 1000);
262 }
60613dc8
WD
263 rprintf(FINFO,"Total bytes sent: %s\n",
264 human_num(total_written));
265 rprintf(FINFO,"Total bytes received: %s\n",
266 human_num(total_read));
7a6421fa 267 }
d9c7edf6 268
e19452a9 269 if (verbose || do_stats) {
b64ee91a 270 rprintf(FCLIENT, "\n");
b9f592fb 271 rprintf(FINFO,
b64ee91a 272 "sent %s bytes received %s bytes %s bytes/sec\n",
60613dc8
WD
273 human_num(total_written), human_num(total_read),
274 human_dnum((total_written + total_read)/(0.5 + (endtime - starttime)), 2));
275 rprintf(FINFO, "total size is %s speedup is %.2f\n",
276 human_num(stats.total_size),
b9f592fb 277 (double)stats.total_size / (total_written+total_read));
e19452a9 278 }
fc8a6b97
AT
279
280 fflush(stdout);
281 fflush(stderr);
c627d613
AT
282}
283
284
e5a2b854
MP
285/**
286 * If our C library can get malloc statistics, then show them to FINFO
287 **/
288static void show_malloc_stats(void)
289{
4f5b0756 290#ifdef HAVE_MALLINFO
e5a2b854
MP
291 struct mallinfo mi;
292
293 mi = mallinfo();
294
b64ee91a
WD
295 rprintf(FCLIENT, "\n");
296 rprintf(FINFO, RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
f846a9bf
WD
297 getpid(), am_server ? "server " : "",
298 am_daemon ? "daemon " : "", who_am_i());
299 rprintf(FINFO, " arena: %10ld (bytes from sbrk)\n",
300 (long)mi.arena);
301 rprintf(FINFO, " ordblks: %10ld (chunks not in use)\n",
302 (long)mi.ordblks);
303 rprintf(FINFO, " smblks: %10ld\n",
304 (long)mi.smblks);
305 rprintf(FINFO, " hblks: %10ld (chunks from mmap)\n",
306 (long)mi.hblks);
307 rprintf(FINFO, " hblkhd: %10ld (bytes from mmap)\n",
308 (long)mi.hblkhd);
309 rprintf(FINFO, " allmem: %10ld (bytes from sbrk + mmap)\n",
310 (long)mi.arena + mi.hblkhd);
311 rprintf(FINFO, " usmblks: %10ld\n",
312 (long)mi.usmblks);
313 rprintf(FINFO, " fsmblks: %10ld\n",
314 (long)mi.fsmblks);
315 rprintf(FINFO, " uordblks: %10ld (bytes used)\n",
316 (long)mi.uordblks);
317 rprintf(FINFO, " fordblks: %10ld (bytes free)\n",
318 (long)mi.fordblks);
319 rprintf(FINFO, " keepcost: %10ld (bytes in releasable chunk)\n",
320 (long)mi.keepcost);
e5a2b854
MP
321#endif /* HAVE_MALLINFO */
322}
323
324
0882faa2 325/* Start the remote shell. cmd may be NULL to use the default. */
f7e5068d
WD
326static pid_t do_cmd(char *cmd, char *machine, char *user, char **remote_argv, int remote_argc,
327 int *f_in_p, int *f_out_p)
c627d613 328{
6c2e5b56 329 int i, argc = 0;
887e553f 330 char *args[MAX_ARGS];
19b27a48 331 pid_t ret;
82f0c63e 332 char *dir = NULL;
bb4aa89c 333 int dash_l_set = 0;
366345fe 334
088aac85 335 if (!read_batch && !local_server) {
82f0c63e 336 char *t, *f, in_quote = '\0';
9af87151 337 char *rsh_env = getenv(RSYNC_RSH_ENV);
366345fe 338 if (!cmd)
9af87151 339 cmd = rsh_env;
366345fe
AT
340 if (!cmd)
341 cmd = RSYNC_RSH;
342 cmd = strdup(cmd);
d9c7edf6 343 if (!cmd)
366345fe
AT
344 goto oom;
345
82f0c63e
WD
346 for (t = f = cmd; *f; f++) {
347 if (*f == ' ')
348 continue;
e7a392c7 349 /* Comparison leaves rooms for server_options(). */
f7e5068d
WD
350 if (argc >= MAX_ARGS - MAX_SERVER_ARGS)
351 goto arg_overflow;
82f0c63e
WD
352 args[argc++] = t;
353 while (*f != ' ' || in_quote) {
354 if (!*f) {
355 if (in_quote) {
356 rprintf(FERROR,
357 "Missing trailing-%c in remote-shell command.\n",
358 in_quote);
359 exit_cleanup(RERR_SYNTAX);
360 }
361 f--;
362 break;
363 }
364 if (*f == '\'' || *f == '"') {
365 if (!in_quote) {
366 in_quote = *f++;
367 continue;
368 }
369 if (*f == in_quote && *++f != in_quote) {
370 in_quote = '\0';
371 continue;
372 }
373 }
374 *t++ = *f++;
375 }
376 *t++ = '\0';
887e553f 377 }
c627d613 378
d9c7edf6 379 /* check to see if we've already been given '-l user' in
9af87151 380 * the remote-shell command */
bb4aa89c
WD
381 for (i = 0; i < argc-1; i++) {
382 if (!strcmp(args[i], "-l") && args[i+1][0] != '-')
383 dash_l_set = 1;
384 }
385
4f5b0756 386#ifdef HAVE_REMSH
366345fe
AT
387 /* remsh (on HPUX) takes the arguments the other way around */
388 args[argc++] = machine;
bb4aa89c 389 if (user && !(daemon_over_rsh && dash_l_set)) {
366345fe
AT
390 args[argc++] = "-l";
391 args[argc++] = user;
392 }
7b8356d0 393#else
bb4aa89c 394 if (user && !(daemon_over_rsh && dash_l_set)) {
366345fe
AT
395 args[argc++] = "-l";
396 args[argc++] = user;
397 }
398 args[argc++] = machine;
7b8356d0 399#endif
c627d613 400
366345fe 401 args[argc++] = rsync_path;
c627d613 402
9af87151 403 if (blocking_io < 0) {
90e22f4b
WD
404 char *cp;
405 if ((cp = strrchr(cmd, '/')) != NULL)
406 cp++;
407 else
408 cp = cmd;
409 if (strcmp(cp, "rsh") == 0 || strcmp(cp, "remsh") == 0)
410 blocking_io = 1;
66b71163 411 }
e384bfbd 412
93689aa5 413 server_options(args,&argc);
e7a392c7 414
f7e5068d
WD
415 if (argc >= MAX_ARGS - 2)
416 goto arg_overflow;
366345fe 417 }
c627d613 418
366345fe 419 args[argc++] = ".";
76076c4b 420
f7e5068d
WD
421 if (!daemon_over_rsh) {
422 while (remote_argc > 0) {
423 if (argc >= MAX_ARGS - 1) {
424 arg_overflow:
425 rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
426 exit_cleanup(RERR_SYNTAX);
427 }
428 args[argc++] = *remote_argv++;
429 remote_argc--;
430 }
431 }
c627d613 432
366345fe 433 args[argc] = NULL;
c627d613 434
366345fe 435 if (verbose > 3) {
e7a392c7 436 for (i = 0; i < argc; i++)
b64ee91a
WD
437 rprintf(FCLIENT, "cmd[%d]=%s ", i, args[i]);
438 rprintf(FCLIENT, "\n");
366345fe
AT
439 }
440
c0d8e84c
WD
441 if (read_batch) {
442 int from_gen_pipe[2];
443 if (fd_pair(from_gen_pipe) < 0) {
444 rsyserr(FERROR, errno, "pipe");
445 exit_cleanup(RERR_IPC);
446 }
447 batch_gen_fd = from_gen_pipe[0];
f7e5068d
WD
448 *f_out_p = from_gen_pipe[1];
449 *f_in_p = batch_fd;
c0d8e84c 450 ret = -1; /* no child pid */
b61665d5 451 setup_iconv();
c0d8e84c 452 } else if (local_server) {
b1df18d7
WD
453 /* If the user didn't request --[no-]whole-file, force
454 * it on, but only if we're not batch processing. */
c0d8e84c 455 if (whole_file < 0 && !write_batch)
b1df18d7 456 whole_file = 1;
f7e5068d 457 ret = local_child(argc, args, f_in_p, f_out_p, child_main);
b61665d5 458 setup_iconv();
f7e5068d 459 } else {
b61665d5 460 setup_iconv();
f7e5068d 461 if (protect_args) {
71605b0f
WD
462 int fd;
463#ifdef ICONV_OPTION
464 int convert = ic_send != (iconv_t)-1;
465 xbuf outbuf, inbuf;
466
467 if (convert)
468 alloc_xbuf(&outbuf, 1024);
469#endif
470
f7e5068d 471 ret = piped_child(args, f_in_p, f_out_p);
71605b0f
WD
472
473 for (i = 0; args[i]; i++) {} /* find first NULL */
474 args[i] = "rsync"; /* set a new arg0 */
475 if (verbose > 1)
476 print_child_argv("protected args:", args + i + 1);
477 fd = *f_out_p;
478 do {
479#ifdef ICONV_OPTION
480 if (convert) {
481 INIT_XBUF_STRLEN(inbuf, args[i]);
482 iconvbufs(ic_send, &inbuf, &outbuf,
483 ICB_EXPAND_OUT | ICB_INCLUDE_BAD | ICB_INCLUDE_INCOMPLETE);
484 outbuf.buf[outbuf.len] = '\0';
485 write_buf(fd, outbuf.buf, outbuf.len + 1);
486 outbuf.len = 0;
487 } else
488#endif
489 write_buf(fd, args[i], strlen(args[i]) + 1);
490 } while (args[++i]);
491 write_byte(fd, 0);
492#ifdef ICONV_OPTION
493 if (convert)
494 free(outbuf.buf);
495#endif
f7e5068d
WD
496 } else
497 ret = piped_child(args, f_in_p, f_out_p);
498 }
c627d613 499
3a69fad0
WD
500 if (dir)
501 free(dir);
82306bf6 502
366345fe 503 return ret;
c627d613 504
acee11fc 505 oom:
366345fe
AT
506 out_of_memory("do_cmd");
507 return 0; /* not reached */
c627d613
AT
508}
509
eb598fac
WD
510/* The receiving side operates in one of two modes:
511 *
cc8c5057
WD
512 * 1. it receives any number of files into a destination directory,
513 * placing them according to their names in the file-list.
eb598fac
WD
514 *
515 * 2. it receives a single file and saves it using the name in the
516 * destination path instead of its file-list name. This requires a
517 * "local name" for writing out the destination file.
518 *
a7d461fc
WD
519 * So, our task is to figure out what mode/local-name we need.
520 * For mode 1, we change into the destination directory and return NULL.
521 * For mode 2, we change into the directory containing the destination
522 * file (if we aren't already there) and return the local-name. */
eb598fac 523static char *get_local_name(struct file_list *flist, char *dest_path)
c627d613 524{
7a6421fa 525 STRUCT_STAT st;
a7d461fc 526 int statret;
eb598fac 527 char *cp;
c627d613 528
eb598fac
WD
529 if (verbose > 2) {
530 rprintf(FINFO, "get_local_name count=%d %s\n",
f3d6d480 531 file_total, NS(dest_path));
eb598fac 532 }
1f0610ef 533
ee8e2b15 534 if (!dest_path || list_only)
1f0610ef 535 return NULL;
c95da96a 536
a7d461fc 537 /* See what currently exists at the destination. */
1a7f3d99 538 if ((statret = do_stat(dest_path, &st)) == 0) {
a7d461fc 539 /* If the destination is a dir, enter it and use mode 1. */
1ff5450d 540 if (S_ISDIR(st.st_mode)) {
615a5415 541 if (!push_dir(dest_path, 0)) {
982e05bb 542 rsyserr(FERROR, errno, "push_dir#1 %s failed",
eb598fac 543 full_fname(dest_path));
65417579 544 exit_cleanup(RERR_FILESELECT);
1ff5450d
AT
545 }
546 return NULL;
547 }
f3d6d480 548 if (file_total > 1) {
eb598fac
WD
549 rprintf(FERROR,
550 "ERROR: destination must be a directory when"
551 " copying more than 1 file\n");
65417579 552 exit_cleanup(RERR_FILESELECT);
1ff5450d 553 }
f3d6d480 554 if (file_total == 1 && S_ISDIR(flist->files[0]->mode)) {
44c26bf2
WD
555 rprintf(FERROR,
556 "ERROR: cannot overwrite non-directory"
557 " with a directory\n");
558 exit_cleanup(RERR_FILESELECT);
559 }
cc8c5057 560 } else if (errno != ENOENT) {
a7d461fc
WD
561 /* If we don't know what's at the destination, fail. */
562 rsyserr(FERROR, errno, "ERROR: cannot stat destination %s",
cc8c5057
WD
563 full_fname(dest_path));
564 exit_cleanup(RERR_FILESELECT);
1ff5450d
AT
565 }
566
eb598fac
WD
567 cp = strrchr(dest_path, '/');
568
a7d461fc
WD
569 /* If we need a destination directory because the transfer is not
570 * of a single non-directory or the user has requested one via a
571 * destination path ending in a slash, create one and use mode 1. */
f3d6d480 572 if (file_total > 1 || (cp && !cp[1])) {
eb598fac
WD
573 /* Lop off the final slash (if any). */
574 if (cp && !cp[1])
575 *cp = '\0';
576
a7d461fc
WD
577 if (statret == 0) {
578 rprintf(FERROR,
579 "ERROR: destination path is not a directory\n");
580 exit_cleanup(RERR_SYNTAX);
581 }
582
05278935 583 if (mkdir_defmode(dest_path) != 0) {
eb598fac
WD
584 rsyserr(FERROR, errno, "mkdir %s failed",
585 full_fname(dest_path));
586 exit_cleanup(RERR_FILEIO);
587 }
1ff5450d 588
7341ee2d
WD
589 if (flist->high >= flist->low
590 && strcmp(flist->files[flist->low]->basename, ".") == 0)
288b12ee 591 flist->files[0]->flags |= FLAG_DIR_CREATED;
2a94207a 592
eb598fac
WD
593 if (verbose)
594 rprintf(FINFO, "created directory %s\n", dest_path);
595
596 if (dry_run) {
615a5415 597 /* Indicate that dest dir doesn't really exist. */
eb598fac 598 dry_run++;
eb598fac
WD
599 }
600
615a5415 601 if (!push_dir(dest_path, dry_run > 1)) {
eb598fac
WD
602 rsyserr(FERROR, errno, "push_dir#2 %s failed",
603 full_fname(dest_path));
604 exit_cleanup(RERR_FILESELECT);
605 }
e5a96f0f 606
e5a96f0f 607 return NULL;
1ff5450d
AT
608 }
609
eb598fac
WD
610 /* Otherwise, we are writing a single file, possibly on top of an
611 * existing non-directory. Change to the item's parent directory
612 * (if it has a path component), return the basename of the
613 * destination file as the local name, and use mode 2. */
614 if (!cp)
615 return dest_path;
616
617 if (cp == dest_path)
618 dest_path = "/";
619
620 *cp = '\0';
615a5415 621 if (!push_dir(dest_path, 0)) {
eb598fac
WD
622 rsyserr(FERROR, errno, "push_dir#3 %s failed",
623 full_fname(dest_path));
65417579 624 exit_cleanup(RERR_FILESELECT);
1ff5450d 625 }
eb598fac 626 *cp = '/';
1ff5450d 627
eb598fac 628 return cp + 1;
c627d613
AT
629}
630
615a5415
WD
631/* Call this if the destination dir (which is assumed to be in curr_dir)
632 * does not yet exist and we can't create it due to being in dry-run
633 * mode. We'll fix dirs that can be relative to the non-existent dir. */
634static void fix_basis_dirs(void)
635{
ddcba3f0 636 char **dir, *new, *slash;
615a5415
WD
637 int len;
638
ddcba3f0
WD
639 if (dry_run <= 1)
640 return;
641
642 slash = strrchr(curr_dir, '/');
643
615a5415
WD
644 for (dir = basis_dir; *dir; dir++) {
645 if (**dir == '/')
646 continue;
647 len = curr_dir_len + 1 + strlen(*dir) + 1;
648 if (!(new = new_array(char, len)))
649 out_of_memory("fix_basis_dirs");
ddcba3f0
WD
650 if (slash && strncmp(*dir, "../", 3) == 0) {
651 /* We want to remove only one leading "../" prefix for
652 * the directory we couldn't create in dry-run mode:
653 * this ensures that any other ".." references get
654 * evaluated the same as they would for a live copy. */
655 *slash = '\0';
656 pathjoin(new, len, curr_dir, *dir + 3);
657 *slash = '/';
658 } else
659 pathjoin(new, len, curr_dir, *dir);
615a5415
WD
660 *dir = new;
661 }
662}
c627d613 663
1a8e5c97 664/* This is only called by the sender. */
16edf865 665static void read_final_goodbye(int f_in)
4e0fcd85 666{
f3d6d480
WD
667 int i, iflags, xlen;
668 uchar fnamecmp_type;
669 char xname[MAXPATHLEN];
1a8e5c97
WD
670
671 if (protocol_version < 29)
672 i = read_int(f_in);
673 else {
16edf865
WD
674 i = read_ndx_and_attrs(f_in, &iflags, &fnamecmp_type,
675 xname, &xlen);
4e0fcd85
WD
676 }
677
82ad07c4 678 if (i != NDX_DONE) {
c7791b8c
WD
679 rprintf(FERROR, "Invalid packet at end of run (%d) [%s]\n",
680 i, who_am_i());
1a8e5c97 681 exit_cleanup(RERR_PROTOCOL);
4e0fcd85
WD
682 }
683}
684
eb598fac 685static void do_server_sender(int f_in, int f_out, int argc, char *argv[])
c627d613 686{
7a6421fa
AT
687 struct file_list *flist;
688 char *dir = argv[0];
c627d613 689
45e08edb
WD
690 if (verbose > 2) {
691 rprintf(FINFO, "server_sender starting pid=%ld\n",
692 (long)getpid());
693 }
d9c7edf6 694
2adbcdc7 695 if (am_daemon && lp_write_only(module_id)) {
7a92ded3
WD
696 rprintf(FERROR, "ERROR: module is write only\n");
697 exit_cleanup(RERR_SYNTAX);
698 return;
699 }
47c11975 700 if (am_daemon && lp_read_only(module_id) && remove_source_files) {
bf26aa22 701 rprintf(FERROR,
044ccbaa 702 "ERROR: --remove-%s-files cannot be used with a read-only module\n",
47c11975 703 remove_source_files == 1 ? "source" : "sent");
bf26aa22
WD
704 exit_cleanup(RERR_SYNTAX);
705 return;
706 }
7a92ded3 707
582c1589 708 if (!relative_paths) {
615a5415 709 if (!push_dir(dir, 0)) {
582c1589
WD
710 rsyserr(FERROR, errno, "push_dir#3 %s failed",
711 full_fname(dir));
712 exit_cleanup(RERR_FILESELECT);
713 }
7a6421fa
AT
714 }
715 argc--;
716 argv++;
d9c7edf6 717
48a1ff0d 718 if (argc == 0 && (recurse || list_only)) {
e1f67417 719 argc = 1;
7a6421fa
AT
720 argv--;
721 argv[0] = ".";
722 }
d9c7edf6 723
7a6421fa 724 flist = send_file_list(f_out,argc,argv);
9decb4d2 725 if (!flist || flist->used == 0)
8d9dc9f9 726 exit_cleanup(0);
8d9dc9f9 727
f3d6d480 728 io_start_buffering_in(f_in);
da3478b2 729
f3d6d480 730 send_files(f_in, f_out);
f1e3656e 731 io_flush(FULL_FLUSH);
33c4b445 732 handle_stats(f_out);
4e0fcd85 733 if (protocol_version >= 24)
16edf865 734 read_final_goodbye(f_in);
f1e3656e 735 io_flush(FULL_FLUSH);
7a6421fa 736 exit_cleanup(0);
c627d613
AT
737}
738
739
f3d6d480 740static int do_recv(int f_in, int f_out, char *local_name)
dc5ddbcc 741{
d186eb1a 742 int pid;
84e6d6fd 743 int exit_code = 0;
c70e07d9 744 int error_pipe[2];
dc5ddbcc 745
bb6721dc
WD
746 /* The receiving side mustn't obey this, or an existing symlink that
747 * points to an identical file won't be replaced by the referent. */
a695b379 748 copy_links = copy_dirlinks = 0;
bb6721dc 749
1e1ca253 750#ifdef SUPPORT_HARD_LINKS
d4d6646a 751 if (preserve_hard_links && !inc_recurse)
da131912 752 match_hard_links(first_flist);
1e1ca253 753#endif
dc5ddbcc 754
c70e07d9 755 if (fd_pair(error_pipe) < 0) {
ab759cd2 756 rsyserr(FERROR, errno, "pipe failed in do_recv");
c8f2f857 757 exit_cleanup(RERR_IPC);
554e0a8d 758 }
d9c7edf6 759
f1e3656e 760 io_flush(NORMAL_FLUSH);
c6e7fcb4 761
ba449e44 762 if ((pid = do_fork()) == -1) {
c8f2f857 763 rsyserr(FERROR, errno, "fork failed in do_recv");
ba449e44
WD
764 exit_cleanup(RERR_IPC);
765 }
766
767 if (pid == 0) {
554e0a8d 768 close(error_pipe[0]);
3a69fad0
WD
769 if (f_in != f_out)
770 close(f_out);
e08c9610 771
554e0a8d 772 /* we can't let two processes write to the socket at one time */
f3d6d480 773 io_end_multiplex_out();
554e0a8d
AT
774
775 /* set place to send errors */
f1e3656e 776 set_msg_fd_out(error_pipe[1]);
f3d6d480 777 io_start_buffering_out(error_pipe[1]);
554e0a8d 778
f3d6d480 779 recv_files(f_in, local_name);
f1e3656e 780 io_flush(FULL_FLUSH);
33c4b445 781 handle_stats(f_in);
e08c9610 782
332cf6df 783 send_msg(MSG_DONE, "", 1, 0);
a72ba0cf 784 write_varlong(error_pipe[1], stats.total_read, 3);
f1e3656e 785 io_flush(FULL_FLUSH);
4e0fcd85 786
40df65fd
WD
787 /* Handle any keep-alive packets from the post-processing work
788 * that the generator does. */
4e0fcd85 789 if (protocol_version >= 29) {
f3d6d480
WD
790 int iflags, xlen;
791 uchar fnamecmp_type;
792 char xname[MAXPATHLEN];
793
051182cb 794 kluge_around_eof = -1;
1a8e5c97
WD
795
796 /* This should only get stopped via a USR2 signal. */
16edf865 797 read_ndx_and_attrs(f_in, &iflags, &fnamecmp_type,
f3d6d480 798 xname, &xlen);
1a8e5c97 799
3485ae83
WD
800 rprintf(FERROR, "Invalid packet at end of run [%s]\n",
801 who_am_i());
1a8e5c97 802 exit_cleanup(RERR_PROTOCOL);
4e0fcd85
WD
803 }
804
9e0582f9
WD
805 /* Finally, we go to sleep until our parent kills us with a
806 * USR2 signal. We sleep for a short time, as on some OSes
807 * a signal won't interrupt a sleep! */
f1e3656e
WD
808 while (1)
809 msleep(20);
d186eb1a 810 }
dc5ddbcc 811
b695f242 812 am_generator = 1;
f3d6d480
WD
813
814 io_end_multiplex_in();
e8a96e27 815 if (write_batch && !am_server)
b9f592fb 816 stop_write_batch();
b695f242 817
554e0a8d 818 close(error_pipe[1]);
3a69fad0
WD
819 if (f_in != f_out)
820 close(f_in);
e1b3d5c4 821
f3d6d480 822 io_start_buffering_out(f_out);
b3e10ed7 823
f1e3656e 824 set_msg_fd_in(error_pipe[0]);
f3d6d480 825 io_start_buffering_in(error_pipe[0]);
554e0a8d 826
da131912
WD
827#ifdef SUPPORT_HARD_LINKS
828 if (preserve_hard_links && inc_recurse) {
829 struct file_list *flist;
830 for (flist = first_flist; flist; flist = flist->next)
831 match_hard_links(flist);
832 }
833#endif
834
f3d6d480 835 generate_files(f_out, local_name);
8d9dc9f9 836
33c4b445 837 handle_stats(-1);
f1e3656e 838 io_flush(FULL_FLUSH);
d04e9c51 839 if (protocol_version >= 24) {
8ada7518 840 /* send a final goodbye message */
9ae7a2cd 841 write_ndx(f_out, NDX_DONE);
8ada7518 842 }
f1e3656e 843 io_flush(FULL_FLUSH);
8ada7518 844
f1e3656e 845 set_msg_fd_in(-1);
089a2435 846 kill(pid, SIGUSR2);
84e6d6fd
WD
847 wait_process_with_flush(pid, &exit_code);
848 return exit_code;
dc5ddbcc
AT
849}
850
f3d6d480 851static void do_server_recv(int f_in, int f_out, int argc, char *argv[])
c627d613 852{
84e6d6fd 853 int exit_code;
7a6421fa 854 struct file_list *flist;
6c2e5b56 855 char *local_name = NULL;
7a6421fa 856 char *dir = NULL;
07bff66f
WD
857 int save_verbose = verbose;
858
859 if (filesfrom_fd >= 0) {
860 /* We can't mix messages with files-from data on the socket,
861 * so temporarily turn off verbose messages. */
862 verbose = 0;
863 }
f0fca04e 864
45e08edb
WD
865 if (verbose > 2) {
866 rprintf(FINFO, "server_recv(%d) starting pid=%ld\n",
867 argc, (long)getpid());
868 }
09b7f5db 869
2adbcdc7 870 if (am_daemon && lp_read_only(module_id)) {
09b7f5db
AT
871 rprintf(FERROR,"ERROR: module is read only\n");
872 exit_cleanup(RERR_SYNTAX);
873 return;
874 }
875
7a6421fa
AT
876 if (argc > 0) {
877 dir = argv[0];
878 argc--;
879 argv++;
615a5415 880 if (!am_daemon && !push_dir(dir, 0)) {
982e05bb
WD
881 rsyserr(FERROR, errno, "push_dir#4 %s failed",
882 full_fname(dir));
65417579 883 exit_cleanup(RERR_FILESELECT);
d9c7edf6 884 }
7a6421fa 885 }
c627d613 886
f3d6d480
WD
887 if (protocol_version >= 30)
888 io_start_multiplex_in();
889 else
890 io_start_buffering_in(f_in);
57dee64e 891 recv_filter_list(f_in);
c627d613 892
7c2a9e76 893 if (filesfrom_fd >= 0) {
07bff66f
WD
894 /* We need to send the files-from names to the sender at the
895 * same time that we receive the file-list from them, so we
896 * need the IO routines to automatically write out the names
897 * onto our f_out socket as we read the file-list. This
898 * avoids both deadlock and extra delays/buffers. */
7c2a9e76
WD
899 io_set_filesfrom_fds(filesfrom_fd, f_out);
900 filesfrom_fd = -1;
901 }
902
b9f592fb 903 flist = recv_file_list(f_in);
4c36a13e
AT
904 if (!flist) {
905 rprintf(FERROR,"server_recv: recv_file_list error\n");
65417579 906 exit_cleanup(RERR_FILESELECT);
7a6421fa 907 }
3ea6e0e7 908 if (inc_recurse && file_total == 1)
f3d6d480
WD
909 recv_additional_file_list(f_in);
910 verbose = save_verbose;
d9c7edf6 911
29fad7a3 912 if (argc > 0)
7a6421fa 913 local_name = get_local_name(flist,argv[0]);
c627d613 914
7c58c991
WD
915 /* Now that we know what our destination directory turned out to be,
916 * we can sanitize the --link-/copy-/compare-dest args correctly. */
917 if (sanitize_paths) {
7c58c991 918 char **dir;
c2c8db91 919 for (dir = basis_dir; *dir; dir++) {
c2a2147a 920 *dir = sanitize_path(NULL, *dir, NULL, curr_dir_depth, NULL);
c2c8db91
WD
921 }
922 if (partial_dir) {
923 partial_dir = sanitize_path(NULL, partial_dir, NULL, curr_dir_depth, NULL);
c2c8db91
WD
924 }
925 }
ddcba3f0 926 fix_basis_dirs();
615a5415 927
c2c8db91
WD
928 if (server_filter_list.head) {
929 char **dir;
930 struct filter_list_struct *elp = &server_filter_list;
931
932 for (dir = basis_dir; *dir; dir++) {
933 if (check_filter(elp, *dir, 1) < 0)
934 goto options_rejected;
935 }
936 if (partial_dir && *partial_dir == '/'
937 && check_filter(elp, partial_dir, 1) < 0) {
938 options_rejected:
939 rprintf(FERROR,
940 "Your options have been rejected by the server.\n");
941 exit_cleanup(RERR_SYNTAX);
942 }
7c58c991
WD
943 }
944
f3d6d480 945 exit_code = do_recv(f_in, f_out, local_name);
84e6d6fd 946 exit_cleanup(exit_code);
c627d613
AT
947}
948
949
734a94a2 950int child_main(int argc, char *argv[])
25d34a5c
MP
951{
952 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
734a94a2 953 return 0;
25d34a5c
MP
954}
955
956
9486289c 957void start_server(int f_in, int f_out, int argc, char *argv[])
366345fe 958{
f0359dd0
AT
959 set_nonblocking(f_in);
960 set_nonblocking(f_out);
961
da3478b2
WD
962 io_set_sock_fds(f_in, f_out);
963 setup_protocol(f_out, f_in);
964
d04e9c51 965 if (protocol_version >= 23)
da3478b2 966 io_start_multiplex_out();
7a6421fa 967
7a6421fa 968 if (am_sender) {
83926d3c 969 keep_dirlinks = 0; /* Must be disabled on the sender. */
bf26aa22
WD
970 if (need_messages_from_generator)
971 io_start_multiplex_in();
7842418b 972 recv_filter_list(f_in);
7a6421fa 973 do_server_sender(f_in, f_out, argc, argv);
07613def 974 } else
7a6421fa 975 do_server_recv(f_in, f_out, argc, argv);
7a6421fa 976 exit_cleanup(0);
366345fe
AT
977}
978
0ba48136
MP
979
980/*
981 * This is called once the connection has been negotiated. It is used
982 * for rsyncd, remote-shell, and local connections.
983 */
19b27a48 984int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
9486289c 985{
088aac85 986 struct file_list *flist = NULL;
84e6d6fd 987 int exit_code = 0, exit_code2 = 0;
9486289c 988 char *local_name = NULL;
19b27a48
AT
989
990 cleanup_child_pid = pid;
67a28eb2 991 if (!read_batch) {
b9f592fb
WD
992 set_nonblocking(f_in);
993 set_nonblocking(f_out);
994 }
f0359dd0 995
da3478b2 996 io_set_sock_fds(f_in, f_out);
6d7b6081
AT
997 setup_protocol(f_out,f_in);
998
18882701
WD
999 /* We set our stderr file handle to blocking because ssh might have
1000 * set it to non-blocking. This can be particularly troublesome if
1001 * stderr is a clone of stdout, because ssh would have set our stdout
1002 * to non-blocking at the same time (which can easily cause us to lose
1003 * output from our print statements). This kluge shouldn't cause ssh
1004 * any problems for how we use it. Note also that we delayed setting
1005 * this until after the above protocol setup so that we know for sure
1006 * that ssh is done twiddling its file descriptors. */
1007 set_blocking(STDERR_FILENO);
1008
9486289c 1009 if (am_sender) {
83926d3c 1010 keep_dirlinks = 0; /* Must be disabled on the sender. */
f3d6d480
WD
1011 if (protocol_version >= 30)
1012 io_start_multiplex_out();
1013 else
1014 io_start_buffering_out(f_out);
860236bf 1015 if (!filesfrom_host)
a0a33ee5 1016 set_msg_fd_in(f_in);
57dee64e 1017 send_filter_list(f_out);
860236bf 1018 if (filesfrom_host)
7c2a9e76 1019 filesfrom_fd = f_in;
b9f592fb 1020
e8a96e27 1021 if (write_batch && !am_server)
b9f592fb 1022 start_write_batch(f_out);
a00628b3 1023 flist = send_file_list(f_out, argc, argv);
a0a33ee5 1024 set_msg_fd_in(-1);
d9c7edf6 1025 if (verbose > 3)
9486289c 1026 rprintf(FINFO,"file list sent\n");
f3d6d480
WD
1027
1028 if (protocol_version >= 23)
1029 io_start_multiplex_in();
e1b3d5c4 1030
f1e3656e 1031 io_flush(NORMAL_FLUSH);
f3d6d480 1032 send_files(f_in, f_out);
f1e3656e 1033 io_flush(FULL_FLUSH);
33c4b445 1034 handle_stats(-1);
4e0fcd85 1035 if (protocol_version >= 24)
16edf865 1036 read_final_goodbye(f_in);
9486289c
AT
1037 if (pid != -1) {
1038 if (verbose > 3)
08a740ff 1039 rprintf(FINFO,"client_run waiting on %d\n", (int) pid);
f1e3656e 1040 io_flush(FULL_FLUSH);
84e6d6fd 1041 wait_process_with_flush(pid, &exit_code);
9486289c 1042 }
33c4b445 1043 output_summary();
c87ae64a 1044 io_flush(FULL_FLUSH);
84e6d6fd 1045 exit_cleanup(exit_code);
9486289c 1046 }
f7632fc6 1047
f3d6d480
WD
1048 if (!read_batch) {
1049 if (protocol_version >= 23)
1050 io_start_multiplex_in();
1051 if (need_messages_from_generator)
1052 io_start_multiplex_out();
1053 }
bf26aa22 1054
26bbb6aa 1055 if (argc == 0) {
48a1ff0d 1056 list_only |= 1;
26bbb6aa
WD
1057 xfer_dirs |= 1;
1058 }
d9c7edf6 1059
57dee64e 1060 send_filter_list(read_batch ? -1 : f_out);
d9c7edf6 1061
7c2a9e76
WD
1062 if (filesfrom_fd >= 0) {
1063 io_set_filesfrom_fds(filesfrom_fd, f_out);
1064 filesfrom_fd = -1;
1065 }
1066
e8a96e27 1067 if (write_batch && !am_server)
b9f592fb 1068 start_write_batch(f_in);
9486289c 1069 flist = recv_file_list(f_in);
3ea6e0e7 1070 if (inc_recurse && file_total == 1)
f3d6d480 1071 recv_additional_file_list(f_in);
d9c7edf6 1072
9decb4d2 1073 if (flist && flist->used > 0) {
9d19f8a5 1074 local_name = get_local_name(flist, argv[0]);
d9c7edf6 1075
ddcba3f0 1076 fix_basis_dirs();
615a5415 1077
f3d6d480 1078 exit_code2 = do_recv(f_in, f_out, local_name);
9d19f8a5
WD
1079 } else {
1080 handle_stats(-1);
1081 output_summary();
1082 }
d9c7edf6 1083
9486289c 1084 if (pid != -1) {
8d9dc9f9 1085 if (verbose > 3)
08a740ff 1086 rprintf(FINFO,"client_run2 waiting on %d\n", (int) pid);
f1e3656e 1087 io_flush(FULL_FLUSH);
84e6d6fd 1088 wait_process_with_flush(pid, &exit_code);
9486289c 1089 }
d9c7edf6 1090
84e6d6fd 1091 return MAX(exit_code, exit_code2);
9486289c
AT
1092}
1093
07613def 1094static int copy_argv(char *argv[])
7169bb4a
MP
1095{
1096 int i;
1097
1098 for (i = 0; argv[i]; i++) {
1099 if (!(argv[i] = strdup(argv[i]))) {
1100 rprintf (FERROR, "out of memory at %s(%d)\n",
1101 __FILE__, __LINE__);
1102 return RERR_MALLOC;
1103 }
1104 }
1105
1106 return 0;
1107}
1108
1109
c1a04ecb 1110/**
0ba48136
MP
1111 * Start a client for either type of remote connection. Work out
1112 * whether the arguments request a remote shell or rsyncd connection,
1113 * and call the appropriate connection function, then run_client.
0b4af330
MP
1114 *
1115 * Calls either start_socket_client (for sockets) or do_cmd and
1116 * client_run (for ssh).
c1a04ecb 1117 **/
fc8a6b97 1118static int start_client(int argc, char *argv[])
5d6bcd44 1119{
f7e5068d
WD
1120 char *p, *shell_machine = NULL, *shell_user = NULL;
1121 char **remote_argv;
1122 int remote_argc;
1123 int f_in, f_out;
19b27a48
AT
1124 int ret;
1125 pid_t pid;
7169bb4a
MP
1126
1127 /* Don't clobber argv[] so that ps(1) can still show the right
d9c7edf6 1128 * command line. */
f7e5068d
WD
1129 if ((ret = copy_argv(argv)) != 0)
1130 return ret;
5d6bcd44 1131
d16c245f 1132 if (!read_batch) { /* for read_batch, NO source is specified */
f7e5068d
WD
1133 char *path = check_for_hostspec(argv[0], &shell_machine, &rsync_port);
1134 if (path) { /* source is remote */
a960239f
WD
1135 char *dummy_host;
1136 int dummy_port = 0;
f7e5068d
WD
1137 *argv = path;
1138 remote_argv = argv;
1139 remote_argc = argc;
1140 argv += argc - 1;
1141 if (argc == 1 || **argv == ':')
1142 argc = 0; /* no dest arg */
a960239f 1143 else if (check_for_hostspec(*argv, &dummy_host, &dummy_port)) {
9425918d
WD
1144 rprintf(FERROR,
1145 "The source and destination cannot both be remote.\n");
1146 exit_cleanup(RERR_SYNTAX);
f7e5068d
WD
1147 } else {
1148 remote_argc--; /* don't count dest */
1149 argc = 1;
9425918d 1150 }
860236bf
WD
1151 if (filesfrom_host && *filesfrom_host
1152 && strcmp(filesfrom_host, shell_machine) != 0) {
7c2a9e76 1153 rprintf(FERROR,
50b31539 1154 "--files-from hostname is not the same as the transfer hostname\n");
7c2a9e76
WD
1155 exit_cleanup(RERR_SYNTAX);
1156 }
42ccb4c0 1157 am_sender = 0;
e208631a
WD
1158 if (rsync_port)
1159 daemon_over_rsh = shell_cmd ? 1 : -1;
42ccb4c0
WD
1160 } else { /* source is local, check dest arg */
1161 am_sender = 1;
1162
f7e5068d 1163 if (argc > 1) {
ee8e2b15 1164 p = argv[--argc];
f7e5068d
WD
1165 remote_argv = argv + argc;
1166 } else {
1167 static char *dotarg[1] = { "." };
1168 p = dotarg[0];
1169 remote_argv = dotarg;
26bbb6aa
WD
1170 list_only |= 1;
1171 xfer_dirs |= 1;
d9c7edf6 1172 }
f7e5068d 1173 remote_argc = 1;
a125c82a 1174
f7e5068d
WD
1175 path = check_for_hostspec(p, &shell_machine, &rsync_port);
1176 if (path && filesfrom_host && *filesfrom_host
860236bf 1177 && strcmp(filesfrom_host, shell_machine) != 0) {
7c2a9e76 1178 rprintf(FERROR,
50b31539 1179 "--files-from hostname is not the same as the transfer hostname\n");
7c2a9e76
WD
1180 exit_cleanup(RERR_SYNTAX);
1181 }
f7e5068d 1182 if (!path) { /* no hostspec found, so src & dest are local */
d9c7edf6 1183 local_server = 1;
860236bf 1184 if (filesfrom_host) {
7c2a9e76 1185 rprintf(FERROR,
50b31539 1186 "--files-from cannot be remote when the transfer is local\n");
7c2a9e76
WD
1187 exit_cleanup(RERR_SYNTAX);
1188 }
860236bf 1189 shell_machine = NULL;
f7e5068d
WD
1190 } else { /* hostspec was found, so dest is remote */
1191 argv[argc] = path;
1192 if (rsync_port)
1193 daemon_over_rsh = shell_cmd ? 1 : -1;
1194 }
5d6bcd44 1195 }
d16c245f 1196 } else { /* read_batch */
d9c7edf6 1197 local_server = 1;
f7e5068d 1198 if (check_for_hostspec(argv[argc-1], &shell_machine, &rsync_port)) {
b9f592fb
WD
1199 rprintf(FERROR, "remote destination is not allowed with --read-batch\n");
1200 exit_cleanup(RERR_SYNTAX);
1201 }
f7e5068d
WD
1202 remote_argv = argv + argc - 1;
1203 remote_argc = 1;
6902ed17
MP
1204 }
1205
f7e5068d 1206 if (am_sender) {
a960239f
WD
1207 char *dummy_host;
1208 int dummy_port = rsync_port;
f7e5068d
WD
1209 int i;
1210 /* For local source, extra source args must not have hostspec. */
1211 for (i = 1; i < argc; i++) {
a960239f 1212 if (check_for_hostspec(argv[i], &dummy_host, &dummy_port)) {
f7e5068d
WD
1213 rprintf(FERROR, "Unexpected remote arg: %s\n", argv[i]);
1214 exit_cleanup(RERR_SYNTAX);
1215 }
1216 }
1217 } else {
a960239f
WD
1218 char *dummy_host;
1219 int dummy_port = rsync_port;
f7e5068d 1220 int i;
a960239f
WD
1221 /* For remote source, any extra source args must have either
1222 * the same hostname or an empty hostname. */
f7e5068d 1223 for (i = 1; i < remote_argc; i++) {
a960239f
WD
1224 char *arg = check_for_hostspec(remote_argv[i], &dummy_host, &dummy_port);
1225 if (!arg) {
f7e5068d
WD
1226 rprintf(FERROR, "Unexpected local arg: %s\n", remote_argv[i]);
1227 rprintf(FERROR, "If arg is a remote file/dir, prefix it with a colon (:).\n");
1228 exit_cleanup(RERR_SYNTAX);
1229 }
a960239f
WD
1230 if (*dummy_host && strcmp(dummy_host, shell_machine) != 0) {
1231 rprintf(FERROR, "All source args must come from the same machine.\n");
1232 exit_cleanup(RERR_SYNTAX);
1233 }
1234 if (rsync_port != dummy_port) {
1235 if (!rsync_port || !dummy_port)
1236 rprintf(FERROR, "All source args must use the same hostspec format.\n");
1237 else
1238 rprintf(FERROR, "All source args must use the same port number.\n");
1239 exit_cleanup(RERR_SYNTAX);
1240 }
1241 remote_argv[i] = arg;
f7e5068d 1242 }
26bbb6aa 1243 if (argc == 0) {
f7e5068d 1244 list_only |= 1;
26bbb6aa
WD
1245 xfer_dirs |= 1;
1246 }
e208631a
WD
1247 }
1248
1249 if (daemon_over_rsh < 0)
f7e5068d 1250 return start_socket_client(shell_machine, remote_argc, remote_argv, argc, argv);
e208631a 1251
a39da29a 1252 if (password_file && !daemon_over_rsh) {
327c559a
WD
1253 rprintf(FERROR, "The --password-file option may only be "
1254 "used when accessing an rsync daemon.\n");
a39da29a
WD
1255 exit_cleanup(RERR_SYNTAX);
1256 }
1257
5d6bcd44 1258 if (shell_machine) {
6fc048f4 1259 p = strrchr(shell_machine,'@');
5d6bcd44
AT
1260 if (p) {
1261 *p = 0;
1262 shell_user = shell_machine;
1263 shell_machine = p+1;
1264 }
1265 }
1266
1267 if (verbose > 3) {
9486289c 1268 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
f7e5068d
WD
1269 NS(shell_cmd), NS(shell_machine), NS(shell_user),
1270 remote_argv ? NS(remote_argv[0]) : "");
5d6bcd44 1271 }
d9c7edf6 1272
f7e5068d
WD
1273 pid = do_cmd(shell_cmd, shell_machine, shell_user, remote_argv, remote_argc,
1274 &f_in, &f_out);
75aeac44
WD
1275
1276 /* if we're running an rsync server on the remote host over a
9af87151 1277 * remote shell command, we need to do the RSYNCD protocol first */
75aeac44
WD
1278 if (daemon_over_rsh) {
1279 int tmpret;
f7e5068d 1280 tmpret = start_inband_exchange(f_in, f_out, shell_user, remote_argc, remote_argv);
75aeac44
WD
1281 if (tmpret < 0)
1282 return tmpret;
1283 }
1284
fc8a6b97
AT
1285 ret = client_run(f_in, f_out, pid, argc, argv);
1286
1287 fflush(stdout);
1288 fflush(stderr);
1289
1290 return ret;
5d6bcd44
AT
1291}
1292
366345fe 1293
067669da
WD
1294static RETSIGTYPE sigusr1_handler(UNUSED(int val))
1295{
6bf32edb 1296 exit_cleanup(RERR_SIGNAL1);
82306bf6
AT
1297}
1298
067669da
WD
1299static RETSIGTYPE sigusr2_handler(UNUSED(int val))
1300{
33c4b445
WD
1301 if (!am_server)
1302 output_summary();
40df65fd 1303 close_all();
33c4b445
WD
1304 if (log_got_error)
1305 _exit(RERR_PARTIAL);
8b35435f
AT
1306 _exit(0);
1307}
1308
6d59ac19 1309RETSIGTYPE remember_children(UNUSED(int val))
067669da 1310{
029c1713 1311#ifdef WNOHANG
ee7118a8
DD
1312 int cnt, status;
1313 pid_t pid;
1314 /* An empty waitpid() loop was put here by Tridge and we could never
d9c7edf6 1315 * get him to explain why he put it in, so rather than taking it
ee7118a8
DD
1316 * out we're instead saving the child exit statuses for later use.
1317 * The waitpid() loop presumably eliminates all possibility of leaving
97d8e709 1318 * zombie children, maybe that's why he did it. */
ee7118a8 1319 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
9af87151
WD
1320 /* save the child's exit status */
1321 for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) {
1322 if (pid_stat_table[cnt].pid == 0) {
1323 pid_stat_table[cnt].pid = pid;
1324 pid_stat_table[cnt].status = status;
1325 break;
1326 }
1327 }
ee7118a8 1328 }
029c1713 1329#endif
8261af74 1330#ifndef HAVE_SIGACTION
6d59ac19 1331 signal(SIGCHLD, remember_children);
60ee01f5 1332#endif
19b27a48
AT
1333}
1334
c0531332
MP
1335
1336/**
1337 * This routine catches signals and tries to send them to gdb.
1338 *
1339 * Because it's called from inside a signal handler it ought not to
1340 * use too many library routines.
1341 *
1342 * @todo Perhaps use "screen -X" instead/as well, to help people
1343 * debugging without easy access to X. Perhaps use an environment
1344 * variable, or just call a script?
1345 *
1346 * @todo The /proc/ magic probably only works on Linux (and
1347 * Solaris?) Can we be more portable?
1348 **/
1349#ifdef MAINTAINER_MODE
4fdc39dd
MP
1350const char *get_panic_action(void)
1351{
1352 const char *cmd_fmt = getenv("RSYNC_PANIC_ACTION");
1353
1354 if (cmd_fmt)
1355 return cmd_fmt;
1356 else
1357 return "xterm -display :0 -T Panic -n Panic "
1358 "-e gdb /proc/%d/exe %d";
1359}
1360
1361
9fb3f7a9
MP
1362/**
1363 * Handle a fatal signal by launching a debugger, controlled by $RSYNC_PANIC_ACTION.
1364 *
1365 * This signal handler is only installed if we were configured with
1366 * --enable-maintainer-mode. Perhaps it should always be on and we
1367 * should just look at the environment variable, but I'm a bit leery
1368 * of a signal sending us into a busy loop.
1369 **/
067669da 1370static RETSIGTYPE rsync_panic_handler(UNUSED(int whatsig))
c0531332
MP
1371{
1372 char cmd_buf[300];
1373 int ret;
4fdc39dd 1374
83078af5
WD
1375 snprintf(cmd_buf, sizeof cmd_buf, get_panic_action(),
1376 getpid(), getpid());
c0531332
MP
1377
1378 /* Unless we failed to execute gdb, we allow the process to
1379 * continue. I'm not sure if that's right. */
1380 ret = system(cmd_buf);
1381 if (ret)
1382 _exit(ret);
1383}
1384#endif
1385
1386
5d6bcd44 1387int main(int argc,char *argv[])
d9c7edf6 1388{
ff81e809 1389 int ret;
66a9dc96
WD
1390 int orig_argc = argc;
1391 char **orig_argv = argv;
8261af74
WD
1392#ifdef HAVE_SIGACTION
1393# ifdef HAVE_SIGPROCMASK
60ee01f5 1394 sigset_t sigmask;
5d6bcd44 1395
60ee01f5 1396 sigemptyset(&sigmask);
8261af74 1397# endif
60ee01f5
WD
1398 sigact.sa_flags = SA_NOCLDSTOP;
1399#endif
1400 SIGACTMASK(SIGUSR1, sigusr1_handler);
1401 SIGACTMASK(SIGUSR2, sigusr2_handler);
6d59ac19 1402 SIGACTMASK(SIGCHLD, remember_children);
c0531332 1403#ifdef MAINTAINER_MODE
60ee01f5
WD
1404 SIGACTMASK(SIGSEGV, rsync_panic_handler);
1405 SIGACTMASK(SIGFPE, rsync_panic_handler);
1406 SIGACTMASK(SIGABRT, rsync_panic_handler);
1407 SIGACTMASK(SIGBUS, rsync_panic_handler);
1408#endif
5d6bcd44 1409
7a6421fa 1410 starttime = time(NULL);
6fe05820 1411 am_root = (MY_UID() == 0);
c627d613 1412
a800434a
AT
1413 memset(&stats, 0, sizeof(stats));
1414
df5e03da
AT
1415 if (argc < 2) {
1416 usage(FERROR);
65417579 1417 exit_cleanup(RERR_SYNTAX);
df5e03da
AT
1418 }
1419
7a6421fa 1420 /* we set a 0 umask so that correct file permissions can be
9af87151 1421 * carried across */
05278935 1422 orig_umask = umask(0);
5d6bcd44 1423
eb598fac
WD
1424#if defined CONFIG_LOCALE && defined HAVE_SETLOCALE
1425 setlocale(LC_CTYPE, "");
1426#endif
1427
50135767 1428 if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
d9c7edf6
WD
1429 /* FIXME: We ought to call the same error-handling
1430 * code here, rather than relying on getopt. */
50135767 1431 option_error();
65417579 1432 exit_cleanup(RERR_SYNTAX);
b11ed3b1 1433 }
5d6bcd44 1434
60ee01f5
WD
1435 SIGACTMASK(SIGINT, sig_int);
1436 SIGACTMASK(SIGHUP, sig_int);
1437 SIGACTMASK(SIGTERM, sig_int);
1438#if defined HAVE_SIGACTION && HAVE_SIGPROCMASK
1439 sigprocmask(SIG_UNBLOCK, &sigmask, NULL);
1440#endif
6b83141d 1441
34758d5c
MP
1442 /* Ignore SIGPIPE; we consistently check error codes and will
1443 * see the EPIPE. */
60ee01f5 1444 SIGACTION(SIGPIPE, SIG_IGN);
55e54e46
WD
1445#ifdef SIGXFSZ
1446 SIGACTION(SIGXFSZ, SIG_IGN);
1447#endif
34758d5c 1448
c226b7c2 1449 /* Initialize push_dir here because on some old systems getcwd
9af87151
WD
1450 * (implemented by forking "pwd" and reading its output) doesn't
1451 * work when there are other child processes. Also, on all systems
1452 * that implement getcwd that way "pwd" can't be found after chroot. */
615a5415 1453 push_dir(NULL, 0);
c226b7c2 1454
44e9e221
WD
1455 init_flist();
1456
e8a96e27 1457 if ((write_batch || read_batch) && !am_server) {
b9f592fb 1458 if (write_batch)
66a9dc96 1459 write_batch_shell_file(orig_argc, orig_argv, argc);
b9f592fb 1460
dbbab0c4
WD
1461 if (read_batch && strcmp(batch_name, "-") == 0)
1462 batch_fd = STDIN_FILENO;
1463 else {
1464 batch_fd = do_open(batch_name,
b9f592fb
WD
1465 write_batch ? O_WRONLY | O_CREAT | O_TRUNC
1466 : O_RDONLY, S_IRUSR | S_IWUSR);
dbbab0c4 1467 }
b9f592fb
WD
1468 if (batch_fd < 0) {
1469 rsyserr(FERROR, errno, "Batch file %s open error",
71903f60 1470 full_fname(batch_name));
b9f592fb
WD
1471 exit_cleanup(RERR_FILEIO);
1472 }
9459290a
WD
1473 if (read_batch)
1474 read_stream_flags(batch_fd);
e10664c5
WD
1475 else
1476 write_stream_flags(batch_fd);
1477
6902ed17 1478 }
e8a96e27
WD
1479 if (write_batch < 0)
1480 dry_run = 1;
6902ed17 1481
b61665d5
WD
1482 if (am_server)
1483 setup_iconv();
1484 else if (am_daemon)
7a6421fa 1485 return daemon_main();
f0fca04e 1486
f7e5068d
WD
1487 if (am_server && protect_args) {
1488 char buf[MAXPATHLEN];
71605b0f 1489 protect_args = 2;
f7e5068d
WD
1490 read_args(STDIN_FILENO, NULL, buf, sizeof buf, 1, &argv, &argc, NULL);
1491 if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
1492 option_error();
1493 exit_cleanup(RERR_SYNTAX);
1494 }
1495 }
1496
08ac228f
AT
1497 if (argc < 1) {
1498 usage(FERROR);
65417579 1499 exit_cleanup(RERR_SYNTAX);
08ac228f
AT
1500 }
1501
7a6421fa 1502 if (am_server) {
f0359dd0
AT
1503 set_nonblocking(STDIN_FILENO);
1504 set_nonblocking(STDOUT_FILENO);
75aeac44
WD
1505 if (am_daemon)
1506 return start_daemon(STDIN_FILENO, STDOUT_FILENO);
7a6421fa
AT
1507 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
1508 }
c627d613 1509
ff81e809 1510 ret = start_client(argc, argv);
d9c7edf6 1511 if (ret == -1)
9098bbf3 1512 exit_cleanup(RERR_STARTCLIENT);
088aac85 1513 else
9098bbf3
MP
1514 exit_cleanup(ret);
1515
0f5a04e3 1516 return ret;
c627d613 1517}