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>
7: * Copyright (C) 2003-2020 Wayne Davison
8: *
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.
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: *
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.
21: */
22:
23: #include "rsync.h"
24: #include "inums.h"
25: #include "ifuncs.h"
26: #include "io.h"
27: #if defined CONFIG_LOCALE && defined HAVE_LOCALE_H
28: #include <locale.h>
29: #endif
30: #include <popt.h>
31: #ifdef __TANDEM
32: #include <floss.h(floss_execlp)>
33: #endif
34: #ifdef SUPPORT_FORCE_CHANGE
35: #include <sys/sysctl.h>
36: #endif
37: #ifdef SUPPORT_HFS_COMPRESSION
38: #include <sys/attr.h> /* For getattrlist() */
39: #include <sys/mount.h> /* For statfs() */
40: #endif
41:
42: extern int force_change;
43: extern int dry_run;
44: extern int list_only;
45: extern int io_timeout;
46: extern int am_root;
47: extern int am_server;
48: extern int am_sender;
49: extern int am_daemon;
50: extern int am_dbadmin;
51: extern int inc_recurse;
52: extern int blocking_io;
53: extern int always_checksum;
54: extern int remove_source_files;
55: extern int output_needs_newline;
56: extern int called_from_signal_handler;
57: extern int need_messages_from_generator;
58: extern int kluge_around_eof;
59: extern int got_xfer_error;
60: extern int force_change;
61: extern int msgs2stderr;
62: extern int module_id;
63: extern int read_only;
64: extern int copy_links;
65: extern int copy_dirlinks;
66: extern int copy_unsafe_links;
67: extern int keep_dirlinks;
68: extern int preserve_hard_links;
69: extern int preserve_hfs_compression;
70: extern int protocol_version;
71: extern int always_checksum;
72: extern int mkpath_dest_arg;
73: extern int file_total;
74: extern int recurse;
75: extern int xfer_dirs;
76: extern int protect_args;
77: extern int relative_paths;
78: extern int sanitize_paths;
79: extern int curr_dir_depth;
80: extern int curr_dir_len;
81: extern int module_id;
82: extern int rsync_port;
83: extern int whole_file;
84: extern int read_batch;
85: extern int write_batch;
86: extern int batch_fd;
87: extern int sock_f_in;
88: extern int sock_f_out;
89: extern int filesfrom_fd;
90: extern int connect_timeout;
91: extern int send_msgs_to_gen;
92: extern dev_t filesystem_dev;
93: extern pid_t cleanup_child_pid;
94: extern size_t bwlimit_writemax;
95: extern unsigned int module_dirlen;
96: extern BOOL flist_receiving_enabled;
97: extern BOOL want_progress_now;
98: extern BOOL shutting_down;
99: extern int backup_dir_len;
100: extern int basis_dir_cnt;
101: extern int default_af_hint;
102: extern struct stats stats;
103: extern char *stdout_format;
104: extern char *logfile_format;
105: extern char *filesfrom_host;
106: extern char *partial_dir;
107: extern char *rsync_path;
108: extern char *db_config;
109: extern char *shell_cmd;
110: extern char *password_file;
111: extern char *backup_dir;
112: extern char *copy_as;
113: extern char *tmpdir;
114: extern char curr_dir[MAXPATHLEN];
115: extern char backup_dir_buf[MAXPATHLEN];
116: extern char *basis_dir[MAX_BASIS_DIRS+1];
117: extern struct file_list *first_flist;
118: extern filter_rule_list daemon_filter_list;
119:
120: uid_t our_uid;
121: gid_t our_gid;
122: int am_receiver = 0; /* Only set to 1 after the receiver/generator fork. */
123: int am_generator = 0; /* Only set to 1 after the receiver/generator fork. */
124: int local_server = 0;
125: int daemon_connection = 0; /* 0 = no daemon, 1 = daemon via remote shell, -1 = daemon via socket */
126: mode_t orig_umask = 0;
127: int batch_gen_fd = -1;
128: int sender_keeps_checksum = 0;
129: int fs_supports_hfs_compression = 0;
130: int raw_argc, cooked_argc;
131: char **raw_argv, **cooked_argv;
132:
133: /* There's probably never more than at most 2 outstanding child processes,
134: * but set it higher, just in case. */
135: #define MAXCHILDPROCS 7
136:
137: #ifdef HAVE_SIGACTION
138: # ifdef HAVE_SIGPROCMASK
139: # define SIGACTMASK(n,h) SIGACTION(n,h), sigaddset(&sigmask,(n))
140: # else
141: # define SIGACTMASK(n,h) SIGACTION(n,h)
142: # endif
143: static struct sigaction sigact;
144: #endif
145:
146: struct pid_status {
147: pid_t pid;
148: int status;
149: } pid_stat_table[MAXCHILDPROCS];
150:
151: static time_t starttime, endtime;
152: static int64 total_read, total_written;
153:
154: static void show_malloc_stats(void);
155:
156: /* Works like waitpid(), but if we already harvested the child pid in our
157: * remember_children(), we succeed instead of returning an error. */
158: pid_t wait_process(pid_t pid, int *status_ptr, int flags)
159: {
160: pid_t waited_pid;
161:
162: do {
163: waited_pid = waitpid(pid, status_ptr, flags);
164: } while (waited_pid == -1 && errno == EINTR);
165:
166: if (waited_pid == -1 && errno == ECHILD) {
167: /* Status of requested child no longer available: check to
168: * see if it was processed by remember_children(). */
169: int cnt;
170: for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) {
171: if (pid == pid_stat_table[cnt].pid) {
172: *status_ptr = pid_stat_table[cnt].status;
173: pid_stat_table[cnt].pid = 0;
174: return pid;
175: }
176: }
177: }
178:
179: return waited_pid;
180: }
181:
182: int shell_exec(const char *cmd)
183: {
184: char *shell = getenv("RSYNC_SHELL");
185: int status;
186: pid_t pid;
187:
188: if (!shell)
189: return system(cmd);
190:
191: if ((pid = fork()) < 0)
192: return -1;
193:
194: if (pid == 0) {
195: execlp(shell, shell, "-c", cmd, NULL);
196: _exit(1);
197: }
198:
199: int ret = wait_process(pid, &status, 0);
200: return ret < 0 ? -1 : status;
201: }
202:
203: /* Wait for a process to exit, calling io_flush while waiting. */
204: void wait_process_with_flush(pid_t pid, int *exit_code_ptr)
205: {
206: pid_t waited_pid;
207: int status;
208:
209: while ((waited_pid = wait_process(pid, &status, WNOHANG)) == 0) {
210: msleep(20);
211: io_flush(FULL_FLUSH);
212: }
213:
214: /* TODO: If the child exited on a signal, then log an
215: * appropriate error message. Perhaps we should also accept a
216: * message describing the purpose of the child. Also indicate
217: * this to the caller so that they know something went wrong. */
218: if (waited_pid < 0) {
219: rsyserr(FERROR, errno, "waitpid");
220: *exit_code_ptr = RERR_WAITCHILD;
221: } else if (!WIFEXITED(status)) {
222: #ifdef WCOREDUMP
223: if (WCOREDUMP(status))
224: *exit_code_ptr = RERR_CRASHED;
225: else
226: #endif
227: if (WIFSIGNALED(status))
228: *exit_code_ptr = RERR_TERMINATED;
229: else
230: *exit_code_ptr = RERR_WAITCHILD;
231: } else {
232: *exit_code_ptr = WEXITSTATUS(status);
233: if (*exit_code_ptr == RERR_WECRASHED)
234: *exit_code_ptr = RERR_CRASHED;
235: }
236: }
237:
238: void write_del_stats(int f)
239: {
240: if (read_batch)
241: write_int(f, NDX_DEL_STATS);
242: else
243: write_ndx(f, NDX_DEL_STATS);
244: write_varint(f, stats.deleted_files - stats.deleted_dirs
245: - stats.deleted_symlinks - stats.deleted_devices
246: - stats.deleted_specials);
247: write_varint(f, stats.deleted_dirs);
248: write_varint(f, stats.deleted_symlinks);
249: write_varint(f, stats.deleted_devices);
250: write_varint(f, stats.deleted_specials);
251: }
252:
253: void read_del_stats(int f)
254: {
255: stats.deleted_files = read_varint(f);
256: stats.deleted_files += stats.deleted_dirs = read_varint(f);
257: stats.deleted_files += stats.deleted_symlinks = read_varint(f);
258: stats.deleted_files += stats.deleted_devices = read_varint(f);
259: stats.deleted_files += stats.deleted_specials = read_varint(f);
260: }
261:
262: static void become_copy_as_user()
263: {
264: char *gname;
265: uid_t uid;
266: gid_t gid;
267:
268: if (!copy_as)
269: return;
270:
271: if (DEBUG_GTE(CMD, 2))
272: rprintf(FINFO, "[%s] copy_as=%s\n", who_am_i(), copy_as);
273:
274: if ((gname = strchr(copy_as, ':')) != NULL)
275: *gname++ = '\0';
276:
277: if (!user_to_uid(copy_as, &uid, True)) {
278: rprintf(FERROR, "Invalid copy-as user: %s\n", copy_as);
279: exit_cleanup(RERR_SYNTAX);
280: }
281:
282: if (gname) {
283: if (!group_to_gid(gname, &gid, True)) {
284: rprintf(FERROR, "Invalid copy-as group: %s\n", gname);
285: exit_cleanup(RERR_SYNTAX);
286: }
287: } else {
288: struct passwd *pw;
289: if ((pw = getpwuid(uid)) == NULL) {
290: rsyserr(FERROR, errno, "getpwuid failed");
291: exit_cleanup(RERR_SYNTAX);
292: }
293: gid = pw->pw_gid;
294: }
295:
296: if (setgid(gid) < 0) {
297: rsyserr(FERROR, errno, "setgid failed");
298: exit_cleanup(RERR_SYNTAX);
299: }
300: #ifdef HAVE_SETGROUPS
301: if (setgroups(1, &gid)) {
302: rsyserr(FERROR, errno, "setgroups failed");
303: exit_cleanup(RERR_SYNTAX);
304: }
305: #endif
306: #ifdef HAVE_INITGROUPS
307: if (!gname && initgroups(copy_as, gid) < 0) {
308: rsyserr(FERROR, errno, "initgroups failed");
309: exit_cleanup(RERR_SYNTAX);
310: }
311: #endif
312:
313: if (setuid(uid) < 0
314: #ifdef HAVE_SETEUID
315: || seteuid(uid) < 0
316: #endif
317: ) {
318: rsyserr(FERROR, errno, "setuid failed");
319: exit_cleanup(RERR_SYNTAX);
320: }
321:
322: our_uid = MY_UID();
323: our_gid = MY_GID();
324: am_root = (our_uid == ROOT_UID);
325:
326: if (gname)
327: gname[-1] = ':';
328: }
329:
330: /* This function gets called from all 3 processes. We want the client side
331: * to actually output the text, but the sender is the only process that has
332: * all the stats we need. So, if we're a client sender, we do the report.
333: * If we're a server sender, we write the stats on the supplied fd. If
334: * we're the client receiver we read the stats from the supplied fd and do
335: * the report. All processes might also generate a set of debug stats, if
336: * the verbose level is high enough (this is the only thing that the
337: * generator process and the server receiver ever do here). */
338: static void handle_stats(int f)
339: {
340: endtime = time(NULL);
341:
342: /* Cache two stats because the read/write code can change it. */
343: total_read = stats.total_read;
344: total_written = stats.total_written;
345:
346: if (INFO_GTE(STATS, 3)) {
347: /* These come out from every process */
348: show_malloc_stats();
349: show_flist_stats();
350: }
351:
352: if (am_generator)
353: return;
354:
355: if (am_daemon) {
356: if (f == -1 || !am_sender)
357: return;
358: }
359:
360: if (am_server) {
361: if (am_sender) {
362: write_varlong30(f, total_read, 3);
363: write_varlong30(f, total_written, 3);
364: write_varlong30(f, stats.total_size, 3);
365: if (protocol_version >= 29) {
366: write_varlong30(f, stats.flist_buildtime, 3);
367: write_varlong30(f, stats.flist_xfertime, 3);
368: }
369: }
370: return;
371: }
372:
373: /* this is the client */
374:
375: if (f < 0 && !am_sender) /* e.g. when we got an empty file list. */
376: ;
377: else if (!am_sender) {
378: /* Read the first two in opposite order because the meaning of
379: * read/write swaps when switching from sender to receiver. */
380: total_written = read_varlong30(f, 3);
381: total_read = read_varlong30(f, 3);
382: stats.total_size = read_varlong30(f, 3);
383: if (protocol_version >= 29) {
384: stats.flist_buildtime = read_varlong30(f, 3);
385: stats.flist_xfertime = read_varlong30(f, 3);
386: }
387: } else if (write_batch) {
388: /* The --read-batch process is going to be a client
389: * receiver, so we need to give it the stats. */
390: write_varlong30(batch_fd, total_read, 3);
391: write_varlong30(batch_fd, total_written, 3);
392: write_varlong30(batch_fd, stats.total_size, 3);
393: if (protocol_version >= 29) {
394: write_varlong30(batch_fd, stats.flist_buildtime, 3);
395: write_varlong30(batch_fd, stats.flist_xfertime, 3);
396: }
397: }
398: }
399:
400: static void output_itemized_counts(const char *prefix, int *counts)
401: {
402: static char *labels[] = { "reg", "dir", "link", "dev", "special" };
403: char buf[1024], *pre = " (";
404: int j, len = 0;
405: int total = counts[0];
406: if (total) {
407: counts[0] -= counts[1] + counts[2] + counts[3] + counts[4];
408: for (j = 0; j < 5; j++) {
409: if (counts[j]) {
410: len += snprintf(buf+len, sizeof buf - len - 2,
411: "%s%s: %s",
412: pre, labels[j], comma_num(counts[j]));
413: pre = ", ";
414: }
415: }
416: buf[len++] = ')';
417: }
418: buf[len] = '\0';
419: rprintf(FINFO, "%s: %s%s\n", prefix, comma_num(total), buf);
420: }
421:
422: static const char *bytes_per_sec_human_dnum(void)
423: {
424: if (starttime == (time_t)-1 || endtime == (time_t)-1)
425: return "UNKNOWN";
426: return human_dnum((total_written + total_read) / (0.5 + (endtime - starttime)), 2);
427: }
428:
429: static void output_summary(void)
430: {
431: if (INFO_GTE(STATS, 2)) {
432: rprintf(FCLIENT, "\n");
433: output_itemized_counts("Number of files", &stats.num_files);
434: if (protocol_version >= 29)
435: output_itemized_counts("Number of created files", &stats.created_files);
436: if (protocol_version >= 31)
437: output_itemized_counts("Number of deleted files", &stats.deleted_files);
438: rprintf(FINFO,"Number of regular files transferred: %s\n",
439: comma_num(stats.xferred_files));
440: rprintf(FINFO,"Total file size: %s bytes\n",
441: human_num(stats.total_size));
442: rprintf(FINFO,"Total transferred file size: %s bytes\n",
443: human_num(stats.total_transferred_size));
444: rprintf(FINFO,"Literal data: %s bytes\n",
445: human_num(stats.literal_data));
446: rprintf(FINFO,"Matched data: %s bytes\n",
447: human_num(stats.matched_data));
448: rprintf(FINFO,"File list size: %s\n",
449: human_num(stats.flist_size));
450: if (stats.flist_buildtime) {
451: rprintf(FINFO,
452: "File list generation time: %s seconds\n",
453: comma_dnum((double)stats.flist_buildtime / 1000, 3));
454: rprintf(FINFO,
455: "File list transfer time: %s seconds\n",
456: comma_dnum((double)stats.flist_xfertime / 1000, 3));
457: }
458: rprintf(FINFO,"Total bytes sent: %s\n",
459: human_num(total_written));
460: rprintf(FINFO,"Total bytes received: %s\n",
461: human_num(total_read));
462: }
463:
464: if (INFO_GTE(STATS, 1)) {
465: rprintf(FCLIENT, "\n");
466: rprintf(FINFO,
467: "sent %s bytes received %s bytes %s bytes/sec\n",
468: human_num(total_written), human_num(total_read),
469: bytes_per_sec_human_dnum());
470: rprintf(FINFO, "total size is %s speedup is %s%s\n",
471: human_num(stats.total_size),
472: comma_dnum((double)stats.total_size / (total_written+total_read), 2),
473: write_batch < 0 ? " (BATCH ONLY)" : dry_run ? " (DRY RUN)" : "");
474: }
475:
476: fflush(stdout);
477: fflush(stderr);
478: }
479:
480:
481: /**
482: * If our C library can get malloc statistics, then show them to FINFO
483: **/
484: static void show_malloc_stats(void)
485: {
486: #ifdef HAVE_MALLINFO
487: struct mallinfo mi;
488:
489: mi = mallinfo();
490:
491: rprintf(FCLIENT, "\n");
492: rprintf(FINFO, RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
493: (int)getpid(), am_server ? "server " : "",
494: am_daemon ? "daemon " : "", who_am_i());
495: rprintf(FINFO, " arena: %10ld (bytes from sbrk)\n",
496: (long)mi.arena);
497: rprintf(FINFO, " ordblks: %10ld (chunks not in use)\n",
498: (long)mi.ordblks);
499: rprintf(FINFO, " smblks: %10ld\n",
500: (long)mi.smblks);
501: rprintf(FINFO, " hblks: %10ld (chunks from mmap)\n",
502: (long)mi.hblks);
503: rprintf(FINFO, " hblkhd: %10ld (bytes from mmap)\n",
504: (long)mi.hblkhd);
505: rprintf(FINFO, " allmem: %10ld (bytes from sbrk + mmap)\n",
506: (long)mi.arena + mi.hblkhd);
507: rprintf(FINFO, " usmblks: %10ld\n",
508: (long)mi.usmblks);
509: rprintf(FINFO, " fsmblks: %10ld\n",
510: (long)mi.fsmblks);
511: rprintf(FINFO, " uordblks: %10ld (bytes used)\n",
512: (long)mi.uordblks);
513: rprintf(FINFO, " fordblks: %10ld (bytes free)\n",
514: (long)mi.fordblks);
515: rprintf(FINFO, " keepcost: %10ld (bytes in releasable chunk)\n",
516: (long)mi.keepcost);
517: #endif /* HAVE_MALLINFO */
518: }
519:
520:
521: /* Start the remote shell. cmd may be NULL to use the default. */
522: static pid_t do_cmd(char *cmd, char *machine, char *user, char **remote_argv, int remote_argc,
523: int *f_in_p, int *f_out_p)
524: {
525: int i, argc = 0;
526: char *args[MAX_ARGS], *need_to_free = NULL;
527: pid_t pid;
528: int dash_l_set = 0;
529:
530: if (!read_batch && !local_server) {
531: char *t, *f, in_quote = '\0';
532: char *rsh_env = getenv(RSYNC_RSH_ENV);
533: if (!cmd)
534: cmd = rsh_env;
535: if (!cmd)
536: cmd = RSYNC_RSH;
537: cmd = need_to_free = strdup(cmd);
538:
539: for (t = f = cmd; *f; f++) {
540: if (*f == ' ')
541: continue;
542: /* Comparison leaves rooms for server_options(). */
543: if (argc >= MAX_ARGS - MAX_SERVER_ARGS)
544: goto arg_overflow;
545: args[argc++] = t;
546: while (*f != ' ' || in_quote) {
547: if (!*f) {
548: if (in_quote) {
549: rprintf(FERROR,
550: "Missing trailing-%c in remote-shell command.\n",
551: in_quote);
552: exit_cleanup(RERR_SYNTAX);
553: }
554: f--;
555: break;
556: }
557: if (*f == '\'' || *f == '"') {
558: if (!in_quote) {
559: in_quote = *f++;
560: continue;
561: }
562: if (*f == in_quote && *++f != in_quote) {
563: in_quote = '\0';
564: continue;
565: }
566: }
567: *t++ = *f++;
568: }
569: *t++ = '\0';
570: }
571:
572: /* NOTE: must preserve t == start of command name until the end of the args handling! */
573: if ((t = strrchr(cmd, '/')) != NULL)
574: t++;
575: else
576: t = cmd;
577:
578: /* Check to see if we've already been given '-l user' in the remote-shell command. */
579: for (i = 0; i < argc-1; i++) {
580: if (!strcmp(args[i], "-l") && args[i+1][0] != '-')
581: dash_l_set = 1;
582: }
583:
584: #ifdef HAVE_REMSH
585: /* remsh (on HPUX) takes the arguments the other way around */
586: args[argc++] = machine;
587: if (user && !(daemon_connection && dash_l_set)) {
588: args[argc++] = "-l";
589: args[argc++] = user;
590: }
591: #else
592: if (user && !(daemon_connection && dash_l_set)) {
593: args[argc++] = "-l";
594: args[argc++] = user;
595: }
596: #ifdef AF_INET
597: if (default_af_hint == AF_INET && strcmp(t, "ssh") == 0)
598: args[argc++] = "-4"; /* we're using ssh so we can add a -4 option */
599: #endif
600: #ifdef AF_INET6
601: if (default_af_hint == AF_INET6 && strcmp(t, "ssh") == 0)
602: args[argc++] = "-6"; /* we're using ssh so we can add a -6 option */
603: #endif
604: args[argc++] = machine;
605: #endif
606:
607: args[argc++] = rsync_path;
608:
609: if (blocking_io < 0 && (strcmp(t, "rsh") == 0 || strcmp(t, "remsh") == 0))
610: blocking_io = 1;
611:
612: if (daemon_connection > 0) {
613: args[argc++] = "--server";
614: args[argc++] = "--daemon";
615: } else
616: server_options(args, &argc);
617:
618: if (argc >= MAX_ARGS - 2)
619: goto arg_overflow;
620: }
621:
622: args[argc++] = ".";
623:
624: if (!daemon_connection) {
625: while (remote_argc > 0) {
626: if (argc >= MAX_ARGS - 1) {
627: arg_overflow:
628: rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
629: exit_cleanup(RERR_SYNTAX);
630: }
631: if (**remote_argv == '-') {
632: if (asprintf(args + argc++, "./%s", *remote_argv++) < 0)
633: out_of_memory("do_cmd");
634: } else
635: args[argc++] = *remote_argv++;
636: remote_argc--;
637: }
638: }
639:
640: args[argc] = NULL;
641:
642: if (DEBUG_GTE(CMD, 2)) {
643: for (i = 0; i < argc; i++)
644: rprintf(FCLIENT, "cmd[%d]=%s ", i, args[i]);
645: rprintf(FCLIENT, "\n");
646: }
647:
648: if (read_batch) {
649: int from_gen_pipe[2];
650: set_allow_inc_recurse();
651: if (fd_pair(from_gen_pipe) < 0) {
652: rsyserr(FERROR, errno, "pipe");
653: exit_cleanup(RERR_IPC);
654: }
655: batch_gen_fd = from_gen_pipe[0];
656: *f_out_p = from_gen_pipe[1];
657: *f_in_p = batch_fd;
658: pid = (pid_t)-1; /* no child pid */
659: #ifdef ICONV_CONST
660: setup_iconv();
661: #endif
662: } else if (local_server) {
663: /* If the user didn't request --[no-]whole-file, force
664: * it on, but only if we're not batch processing. */
665: if (whole_file < 0 && !write_batch)
666: whole_file = 1;
667: set_allow_inc_recurse();
668: pid = local_child(argc, args, f_in_p, f_out_p, child_main);
669: #ifdef ICONV_CONST
670: setup_iconv();
671: #endif
672: } else {
673: pid = piped_child(args, f_in_p, f_out_p);
674: #ifdef ICONV_CONST
675: setup_iconv();
676: #endif
677: if (protect_args && !daemon_connection)
678: send_protected_args(*f_out_p, args);
679: }
680:
681: if (need_to_free)
682: free(need_to_free);
683:
684: return pid;
685: }
686:
687: #ifdef SUPPORT_HFS_COMPRESSION
688: static void hfs_receiver_check(void)
689: {
690: struct statfs fsb;
691: struct attrlist attrs;
692: struct {
693: int32_t len;
694: vol_capabilities_set_t caps;
695: } attrData;
696:
697: if (preserve_hfs_compression != 1)
698: return; /* Nothing to check if --hfs-compression option isn't enabled. */
699:
700: if (statfs(".", &fsb) < 0) {
701: rsyserr(FERROR, errno, "statfs %s failed", curr_dir);
702: exit_cleanup(RERR_FILESELECT);
703: }
704:
705: bzero(&attrs, sizeof attrs);
706: attrs.bitmapcount = ATTR_BIT_MAP_COUNT;
707: attrs.volattr = ATTR_VOL_CAPABILITIES;
708:
709: bzero(&attrData, sizeof attrData);
710: attrData.len = sizeof attrData;
711:
712: if (getattrlist(fsb.f_mntonname, &attrs, &attrData, sizeof attrData, 0) < 0) {
713: rsyserr(FERROR, errno, "getattrlist %s failed", curr_dir);
714: exit_cleanup(RERR_FILESELECT);
715: }
716:
717: if (!(attrData.caps[VOL_CAPABILITIES_FORMAT] & VOL_CAP_FMT_DECMPFS_COMPRESSION)) {
718: rprintf(FERROR, "The destination filesystem does not support HFS+ compression.\n");
719: exit_cleanup(RERR_UNSUPPORTED);
720: }
721: }
722: #endif
723:
724: /* The receiving side operates in one of two modes:
725: *
726: * 1. it receives any number of files into a destination directory,
727: * placing them according to their names in the file-list.
728: *
729: * 2. it receives a single file and saves it using the name in the
730: * destination path instead of its file-list name. This requires a
731: * "local name" for writing out the destination file.
732: *
733: * So, our task is to figure out what mode/local-name we need.
734: * For mode 1, we change into the destination directory and return NULL.
735: * For mode 2, we change into the directory containing the destination
736: * file (if we aren't already there) and return the local-name. */
737: static char *get_local_name(struct file_list *flist, char *dest_path)
738: {
739: STRUCT_STAT st;
740: int statret, trailing_slash;
741: char *cp;
742:
743: if (DEBUG_GTE(RECV, 1)) {
744: rprintf(FINFO, "get_local_name count=%d %s\n",
745: file_total, NS(dest_path));
746: }
747:
748: if (!dest_path || list_only)
749: return NULL;
750:
751: /* Treat an empty string as a copy into the current directory. */
752: if (!*dest_path)
753: dest_path = ".";
754:
755: if (daemon_filter_list.head) {
756: char *slash = strrchr(dest_path, '/');
757: if (slash && (slash[1] == '\0' || (slash[1] == '.' && slash[2] == '\0')))
758: *slash = '\0';
759: else
760: slash = NULL;
761: if ((*dest_path != '.' || dest_path[1] != '\0')
762: && (check_filter(&daemon_filter_list, FLOG, dest_path, 0) < 0
763: || check_filter(&daemon_filter_list, FLOG, dest_path, 1) < 0)) {
764: rprintf(FERROR, "ERROR: daemon has excluded destination \"%s\"\n",
765: dest_path);
766: exit_cleanup(RERR_FILESELECT);
767: }
768: if (slash)
769: *slash = '/';
770: }
771:
772: /* See what currently exists at the destination. */
773: statret = do_stat(dest_path, &st);
774: cp = strrchr(dest_path, '/');
775: trailing_slash = cp && !cp[1];
776:
777: if (mkpath_dest_arg && statret < 0 && (cp || file_total > 1)) {
778: int ret = make_path(dest_path, ACCESSPERMS, file_total > 1 && !trailing_slash ? 0 : MKP_DROP_NAME);
779: if (ret < 0)
780: goto mkdir_error;
781: if (INFO_GTE(NAME, 1)) {
782: if (file_total == 1 || trailing_slash)
783: *cp = '\0';
784: rprintf(FINFO, "created %d director%s for %s\n", ret, ret == 1 ? "y" : "ies", dest_path);
785: if (file_total == 1 || trailing_slash)
786: *cp = '/';
787: }
788: if (file_total > 1 || trailing_slash)
789: statret = do_stat(dest_path, &st);
790: }
791:
792: if (statret == 0) {
793: /* If the destination is a dir, enter it and use mode 1. */
794: if (S_ISDIR(st.st_mode)) {
795: if (!change_dir(dest_path, CD_NORMAL)) {
796: rsyserr(FERROR, errno, "change_dir#1 %s failed",
797: full_fname(dest_path));
798: exit_cleanup(RERR_FILESELECT);
799: }
800: filesystem_dev = st.st_dev; /* ensures --force works right w/-x */
801: #ifdef SUPPORT_HFS_COMPRESSION
802: hfs_receiver_check();
803: #endif
804: return NULL;
805: }
806: if (file_total > 1) {
807: rprintf(FERROR,
808: "ERROR: destination must be a directory when"
809: " copying more than 1 file\n");
810: exit_cleanup(RERR_FILESELECT);
811: }
812: if (file_total == 1 && S_ISDIR(flist->files[0]->mode)) {
813: rprintf(FERROR,
814: "ERROR: cannot overwrite non-directory"
815: " with a directory\n");
816: exit_cleanup(RERR_FILESELECT);
817: }
818: } else if (errno != ENOENT) {
819: /* If we don't know what's at the destination, fail. */
820: rsyserr(FERROR, errno, "ERROR: cannot stat destination %s",
821: full_fname(dest_path));
822: exit_cleanup(RERR_FILESELECT);
823: }
824:
825: /* If we need a destination directory because the transfer is not
826: * of a single non-directory or the user has requested one via a
827: * destination path ending in a slash, create one and use mode 1. */
828: if (file_total > 1 || trailing_slash) {
829: if (trailing_slash)
830: *cp = '\0'; /* Lop off the final slash (if any). */
831:
832: if (statret == 0) {
833: rprintf(FERROR, "ERROR: destination path is not a directory\n");
834: exit_cleanup(RERR_SYNTAX);
835: }
836:
837: if (do_mkdir(dest_path, ACCESSPERMS) != 0) {
838: mkdir_error:
839: rsyserr(FERROR, errno, "mkdir %s failed",
840: full_fname(dest_path));
841: exit_cleanup(RERR_FILEIO);
842: }
843:
844: if (flist->high >= flist->low
845: && strcmp(flist->files[flist->low]->basename, ".") == 0)
846: flist->files[0]->flags |= FLAG_DIR_CREATED;
847:
848: if (INFO_GTE(NAME, 1))
849: rprintf(FINFO, "created directory %s\n", dest_path);
850:
851: if (dry_run) {
852: /* Indicate that dest dir doesn't really exist. */
853: dry_run++;
854: }
855:
856: if (!change_dir(dest_path, dry_run > 1 ? CD_SKIP_CHDIR : CD_NORMAL)) {
857: rsyserr(FERROR, errno, "change_dir#2 %s failed",
858: full_fname(dest_path));
859: exit_cleanup(RERR_FILESELECT);
860: }
861: #ifdef SUPPORT_HFS_COMPRESSION
862: hfs_receiver_check();
863: #endif
864: return NULL;
865: }
866:
867: /* Otherwise, we are writing a single file, possibly on top of an
868: * existing non-directory. Change to the item's parent directory
869: * (if it has a path component), return the basename of the
870: * destination file as the local name, and use mode 2. */
871: if (!cp)
872: return dest_path;
873:
874: if (cp == dest_path)
875: dest_path = "/";
876:
877: *cp = '\0';
878: if (!change_dir(dest_path, CD_NORMAL)) {
879: rsyserr(FERROR, errno, "change_dir#3 %s failed",
880: full_fname(dest_path));
881: exit_cleanup(RERR_FILESELECT);
882: }
883: #ifdef SUPPORT_HFS_COMPRESSION
884: hfs_receiver_check();
885: #endif
886: *cp = '/';
887:
888: return cp + 1;
889: }
890:
891: /* This function checks on our alternate-basis directories. If we're in
892: * dry-run mode and the destination dir does not yet exist, we'll try to
893: * tweak any dest-relative paths to make them work for a dry-run (the
894: * destination dir must be in curr_dir[] when this function is called).
895: * We also warn about any arg that is non-existent or not a directory. */
896: static void check_alt_basis_dirs(void)
897: {
898: STRUCT_STAT st;
899: char *slash = strrchr(curr_dir, '/');
900: int j;
901:
902: for (j = 0; j < basis_dir_cnt; j++) {
903: char *bdir = basis_dir[j];
904: int bd_len = strlen(bdir);
905: if (bd_len > 1 && bdir[bd_len-1] == '/')
906: bdir[--bd_len] = '\0';
907: if (dry_run > 1 && *bdir != '/') {
908: int len = curr_dir_len + 1 + bd_len + 1;
909: char *new = new_array(char, len);
910: if (slash && strncmp(bdir, "../", 3) == 0) {
911: /* We want to remove only one leading "../" prefix for
912: * the directory we couldn't create in dry-run mode:
913: * this ensures that any other ".." references get
914: * evaluated the same as they would for a live copy. */
915: *slash = '\0';
916: pathjoin(new, len, curr_dir, bdir + 3);
917: *slash = '/';
918: } else
919: pathjoin(new, len, curr_dir, bdir);
920: basis_dir[j] = bdir = new;
921: }
922: if (do_stat(bdir, &st) < 0)
923: rprintf(FWARNING, "%s arg does not exist: %s\n", alt_dest_opt(0), bdir);
924: else if (!S_ISDIR(st.st_mode))
925: rprintf(FWARNING, "%s arg is not a dir: %s\n", alt_dest_opt(0), bdir);
926: }
927: }
928:
929: /* This is only called by the sender. */
930: static void read_final_goodbye(int f_in, int f_out)
931: {
932: int i, iflags, xlen;
933: uchar fnamecmp_type;
934: char xname[MAXPATHLEN];
935:
936: shutting_down = True;
937:
938: if (protocol_version < 29)
939: i = read_int(f_in);
940: else {
941: i = read_ndx_and_attrs(f_in, f_out, &iflags, &fnamecmp_type, xname, &xlen);
942: if (protocol_version >= 31 && i == NDX_DONE) {
943: if (am_sender)
944: write_ndx(f_out, NDX_DONE);
945: else {
946: if (batch_gen_fd >= 0) {
947: while (read_int(batch_gen_fd) != NDX_DEL_STATS) {}
948: read_del_stats(batch_gen_fd);
949: }
950: write_int(f_out, NDX_DONE);
951: }
952: i = read_ndx_and_attrs(f_in, f_out, &iflags, &fnamecmp_type, xname, &xlen);
953: }
954: }
955:
956: if (i != NDX_DONE) {
957: rprintf(FERROR, "Invalid packet at end of run (%d) [%s]\n",
958: i, who_am_i());
959: exit_cleanup(RERR_PROTOCOL);
960: }
961: }
962:
963: static void do_server_sender(int f_in, int f_out, int argc, char *argv[])
964: {
965: struct file_list *flist;
966: char *dir;
967:
968: if (DEBUG_GTE(SEND, 1))
969: rprintf(FINFO, "server_sender starting pid=%d\n", (int)getpid());
970:
971: if (am_daemon && lp_write_only(module_id)) {
972: rprintf(FERROR, "ERROR: module is write only\n");
973: exit_cleanup(RERR_SYNTAX);
974: }
975: if (am_daemon && read_only && remove_source_files) {
976: rprintf(FERROR,
977: "ERROR: --remove-%s-files cannot be used with a read-only module\n",
978: remove_source_files == 1 ? "source" : "sent");
979: exit_cleanup(RERR_SYNTAX);
980: }
981: if (argc < 1) {
982: rprintf(FERROR, "ERROR: do_server_sender called without args\n");
983: exit_cleanup(RERR_SYNTAX);
984: }
985:
986: become_copy_as_user();
987:
988: dir = argv[0];
989: if (!relative_paths) {
990: if (!change_dir(dir, CD_NORMAL)) {
991: rsyserr(FERROR, errno, "change_dir#3 %s failed",
992: full_fname(dir));
993: exit_cleanup(RERR_FILESELECT);
994: }
995: }
996: argc--;
997: argv++;
998:
999: if (argc == 0 && (recurse || xfer_dirs || list_only)) {
1000: argc = 1;
1001: argv--;
1002: argv[0] = ".";
1003: }
1004:
1005: flist = send_file_list(f_out,argc,argv);
1006: if (!flist || flist->used == 0) {
1007: /* Make sure input buffering is off so we can't hang in noop_io_until_death(). */
1008: io_end_buffering_in(0);
1009: /* TODO: we should really exit in a more controlled manner. */
1010: exit_cleanup(0);
1011: }
1012:
1013: io_start_buffering_in(f_in);
1014:
1015: send_files(f_in, f_out);
1016: io_flush(FULL_FLUSH);
1017: handle_stats(f_out);
1018: if (protocol_version >= 24)
1019: read_final_goodbye(f_in, f_out);
1020: io_flush(FULL_FLUSH);
1021: exit_cleanup(0);
1022: }
1023:
1024:
1025: static int do_recv(int f_in, int f_out, char *local_name)
1026: {
1027: int pid;
1028: int exit_code = 0;
1029: int error_pipe[2];
1030:
1031: /* The receiving side mustn't obey this, or an existing symlink that
1032: * points to an identical file won't be replaced by the referent. */
1033: copy_links = copy_dirlinks = copy_unsafe_links = 0;
1034:
1035: #ifdef SUPPORT_FORCE_CHANGE
1036: if (force_change & SYS_IMMUTABLE) {
1037: /* Determine whether we'll be able to unlock a system immutable item. */
1038: int mib[2];
1039: int securityLevel = 0;
1040: size_t len = sizeof securityLevel;
1041:
1042: mib[0] = CTL_KERN;
1043: mib[1] = KERN_SECURELVL;
1044: if (sysctl(mib, 2, &securityLevel, &len, NULL, 0) == 0 && securityLevel > 0) {
1045: rprintf(FERROR, "System security level is too high to force mutability on system immutable files and directories.\n");
1046: exit_cleanup(RERR_UNSUPPORTED);
1047: }
1048: }
1049: #endif
1050:
1051: #ifdef SUPPORT_HARD_LINKS
1052: if (preserve_hard_links && !inc_recurse)
1053: match_hard_links(first_flist);
1054: #endif
1055:
1056: if (fd_pair(error_pipe) < 0) {
1057: rsyserr(FERROR, errno, "pipe failed in do_recv");
1058: exit_cleanup(RERR_IPC);
1059: }
1060:
1061: if (backup_dir) {
1062: STRUCT_STAT st;
1063: int ret;
1064: if (backup_dir_len > 1)
1065: backup_dir_buf[backup_dir_len-1] = '\0';
1066: ret = do_stat(backup_dir_buf, &st);
1067: if (ret != 0 || !S_ISDIR(st.st_mode)) {
1068: if (ret == 0) {
1069: rprintf(FERROR, "The backup-dir is not a directory: %s\n", backup_dir_buf);
1070: exit_cleanup(RERR_SYNTAX);
1071: }
1072: if (errno != ENOENT) {
1073: rprintf(FERROR, "Failed to stat %s: %s\n", backup_dir_buf, strerror(errno));
1074: exit_cleanup(RERR_FILEIO);
1075: }
1076: if (INFO_GTE(BACKUP, 1))
1077: rprintf(FINFO, "(new) backup_dir is %s\n", backup_dir_buf);
1078: } else if (INFO_GTE(BACKUP, 1))
1079: rprintf(FINFO, "backup_dir is %s\n", backup_dir_buf);
1080: if (backup_dir_len > 1)
1081: backup_dir_buf[backup_dir_len-1] = '/';
1082: }
1083:
1084: if (tmpdir) {
1085: STRUCT_STAT st;
1086: int ret = do_stat(tmpdir, &st);
1087: if (ret < 0 || !S_ISDIR(st.st_mode)) {
1088: if (ret == 0) {
1089: rprintf(FERROR, "The temp-dir is not a directory: %s\n", tmpdir);
1090: exit_cleanup(RERR_SYNTAX);
1091: }
1092: if (errno == ENOENT) {
1093: rprintf(FERROR, "The temp-dir does not exist: %s\n", tmpdir);
1094: exit_cleanup(RERR_SYNTAX);
1095: }
1096: rprintf(FERROR, "Failed to stat temp-dir %s: %s\n", tmpdir, strerror(errno));
1097: exit_cleanup(RERR_FILEIO);
1098: }
1099: }
1100:
1101: io_flush(FULL_FLUSH);
1102:
1103: if ((pid = do_fork()) == -1) {
1104: rsyserr(FERROR, errno, "fork failed in do_recv");
1105: exit_cleanup(RERR_IPC);
1106: }
1107:
1108: if (pid == 0) {
1109: am_receiver = 1;
1110: send_msgs_to_gen = am_server;
1111:
1112: close(error_pipe[0]);
1113:
1114: /* We can't let two processes write to the socket at one time. */
1115: io_end_multiplex_out(MPLX_SWITCHING);
1116: if (f_in != f_out)
1117: close(f_out);
1118: sock_f_out = -1;
1119: f_out = error_pipe[1];
1120:
1121: bwlimit_writemax = 0; /* receiver doesn't need to do this */
1122:
1123: if (read_batch)
1124: io_start_buffering_in(f_in);
1125: io_start_multiplex_out(f_out);
1126:
1127: recv_files(f_in, f_out, local_name);
1128: io_flush(FULL_FLUSH);
1129: handle_stats(f_in);
1130:
1131: if (output_needs_newline) {
1132: fputc('\n', stdout);
1133: output_needs_newline = 0;
1134: }
1135:
1136: write_int(f_out, NDX_DONE);
1137: send_msg(MSG_STATS, (char*)&stats.total_read, sizeof stats.total_read, 0);
1138: io_flush(FULL_FLUSH);
1139:
1140: /* Handle any keep-alive packets from the post-processing work
1141: * that the generator does. */
1142: if (protocol_version >= 29) {
1143: kluge_around_eof = -1;
1144:
1145: /* This should only get stopped via a USR2 signal. */
1146: read_final_goodbye(f_in, f_out);
1147:
1148: rprintf(FERROR, "Invalid packet at end of run [%s]\n",
1149: who_am_i());
1150: exit_cleanup(RERR_PROTOCOL);
1151: }
1152:
1153: /* Finally, we go to sleep until our parent kills us with a
1154: * USR2 signal. We sleep for a short time, as on some OSes
1155: * a signal won't interrupt a sleep! */
1156: while (1)
1157: msleep(20);
1158: }
1159:
1160: am_generator = 1;
1161: flist_receiving_enabled = True;
1162:
1163: io_end_multiplex_in(MPLX_SWITCHING);
1164: if (write_batch && !am_server)
1165: stop_write_batch();
1166:
1167: close(error_pipe[1]);
1168: if (f_in != f_out)
1169: close(f_in);
1170: sock_f_in = -1;
1171: f_in = error_pipe[0];
1172:
1173: io_start_buffering_out(f_out);
1174: io_start_multiplex_in(f_in);
1175:
1176: #ifdef SUPPORT_HARD_LINKS
1177: if (preserve_hard_links && inc_recurse) {
1178: struct file_list *flist;
1179: for (flist = first_flist; flist; flist = flist->next)
1180: match_hard_links(flist);
1181: }
1182: #endif
1183:
1184: generate_files(f_out, local_name);
1185:
1186: handle_stats(-1);
1187: io_flush(FULL_FLUSH);
1188: shutting_down = True;
1189: if (protocol_version >= 24) {
1190: /* send a final goodbye message */
1191: write_ndx(f_out, NDX_DONE);
1192: }
1193: io_flush(FULL_FLUSH);
1194:
1195: kill(pid, SIGUSR2);
1196: wait_process_with_flush(pid, &exit_code);
1197: return exit_code;
1198: }
1199:
1200: static void do_server_recv(int f_in, int f_out, int argc, char *argv[])
1201: {
1202: int exit_code;
1203: struct file_list *flist;
1204: char *local_name = NULL;
1205: int negated_levels;
1206:
1207: if (filesfrom_fd >= 0 && msgs2stderr != 1 && protocol_version < 31) {
1208: /* We can't mix messages with files-from data on the socket,
1209: * so temporarily turn off info/debug messages. */
1210: negate_output_levels();
1211: negated_levels = 1;
1212: } else
1213: negated_levels = 0;
1214:
1215: if (DEBUG_GTE(RECV, 1))
1216: rprintf(FINFO, "server_recv(%d) starting pid=%d\n", argc, (int)getpid());
1217:
1218: if (am_daemon && read_only) {
1219: rprintf(FERROR,"ERROR: module is read only\n");
1220: exit_cleanup(RERR_SYNTAX);
1221: return;
1222: }
1223:
1224: become_copy_as_user();
1225:
1226: if (argc > 0) {
1227: char *dir = argv[0];
1228: argc--;
1229: argv++;
1230: if (!am_daemon && !change_dir(dir, CD_NORMAL)) {
1231: rsyserr(FERROR, errno, "change_dir#4 %s failed",
1232: full_fname(dir));
1233: exit_cleanup(RERR_FILESELECT);
1234: }
1235: }
1236:
1237: if (protocol_version >= 30)
1238: io_start_multiplex_in(f_in);
1239: else
1240: io_start_buffering_in(f_in);
1241: recv_filter_list(f_in);
1242:
1243: if (filesfrom_fd >= 0) {
1244: /* We need to send the files-from names to the sender at the
1245: * same time that we receive the file-list from them, so we
1246: * need the IO routines to automatically write out the names
1247: * onto our f_out socket as we read the file-list. This
1248: * avoids both deadlock and extra delays/buffers. */
1249: start_filesfrom_forwarding(filesfrom_fd);
1250: filesfrom_fd = -1;
1251: }
1252:
1253: flist = recv_file_list(f_in, -1);
1254: if (!flist) {
1255: rprintf(FERROR,"server_recv: recv_file_list error\n");
1256: exit_cleanup(RERR_FILESELECT);
1257: }
1258: if (inc_recurse && file_total == 1)
1259: recv_additional_file_list(f_in);
1260:
1261: if (negated_levels)
1262: negate_output_levels();
1263:
1264: if (argc > 0)
1265: local_name = get_local_name(flist,argv[0]);
1266:
1267: /* Now that we know what our destination directory turned out to be,
1268: * we can sanitize the --link-/copy-/compare-dest args correctly. */
1269: if (sanitize_paths) {
1270: char **dir_p;
1271: for (dir_p = basis_dir; *dir_p; dir_p++)
1272: *dir_p = sanitize_path(NULL, *dir_p, NULL, curr_dir_depth, SP_DEFAULT);
1273: if (partial_dir)
1274: partial_dir = sanitize_path(NULL, partial_dir, NULL, curr_dir_depth, SP_DEFAULT);
1275: }
1276: check_alt_basis_dirs();
1277:
1278: if (daemon_filter_list.head) {
1279: char **dir_p;
1280: filter_rule_list *elp = &daemon_filter_list;
1281:
1282: for (dir_p = basis_dir; *dir_p; dir_p++) {
1283: char *dir = *dir_p;
1284: if (*dir == '/')
1285: dir += module_dirlen;
1286: if (check_filter(elp, FLOG, dir, 1) < 0)
1287: goto options_rejected;
1288: }
1289: if (partial_dir && *partial_dir == '/'
1290: && check_filter(elp, FLOG, partial_dir + module_dirlen, 1) < 0) {
1291: options_rejected:
1292: rprintf(FERROR, "Your options have been rejected by the server.\n");
1293: exit_cleanup(RERR_SYNTAX);
1294: }
1295: }
1296:
1297: exit_code = do_recv(f_in, f_out, local_name);
1298: exit_cleanup(exit_code);
1299: }
1300:
1301:
1302: int child_main(int argc, char *argv[])
1303: {
1304: start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
1305: return 0;
1306: }
1307:
1308:
1309: void start_server(int f_in, int f_out, int argc, char *argv[])
1310: {
1311: set_nonblocking(f_in);
1312: set_nonblocking(f_out);
1313:
1314: io_set_sock_fds(f_in, f_out);
1315: setup_protocol(f_out, f_in);
1316:
1317: if (protocol_version >= 23)
1318: io_start_multiplex_out(f_out);
1319: if (am_daemon && io_timeout && protocol_version >= 31)
1320: send_msg_int(MSG_IO_TIMEOUT, io_timeout);
1321:
1322: if (db_config)
1323: db_read_config(FERROR, db_config);
1324:
1325: if (am_sender) {
1326: keep_dirlinks = 0; /* Must be disabled on the sender. */
1327: if (need_messages_from_generator)
1328: io_start_multiplex_in(f_in);
1329: else
1330: io_start_buffering_in(f_in);
1331: recv_filter_list(f_in);
1332: do_server_sender(f_in, f_out, argc, argv);
1333: } else
1334: do_server_recv(f_in, f_out, argc, argv);
1335: exit_cleanup(0);
1336: }
1337:
1338: /* This is called once the connection has been negotiated. It is used
1339: * for rsyncd, remote-shell, and local connections. */
1340: int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
1341: {
1342: struct file_list *flist = NULL;
1343: int exit_code = 0, exit_code2 = 0;
1344: char *local_name = NULL;
1345:
1346: cleanup_child_pid = pid;
1347: if (!read_batch) {
1348: set_nonblocking(f_in);
1349: set_nonblocking(f_out);
1350: }
1351:
1352: io_set_sock_fds(f_in, f_out);
1353: setup_protocol(f_out,f_in);
1354:
1355: /* We set our stderr file handle to blocking because ssh might have
1356: * set it to non-blocking. This can be particularly troublesome if
1357: * stderr is a clone of stdout, because ssh would have set our stdout
1358: * to non-blocking at the same time (which can easily cause us to lose
1359: * output from our print statements). This kluge shouldn't cause ssh
1360: * any problems for how we use it. Note also that we delayed setting
1361: * this until after the above protocol setup so that we know for sure
1362: * that ssh is done twiddling its file descriptors. */
1363: set_blocking(STDERR_FILENO);
1364:
1365: if (am_sender) {
1366: keep_dirlinks = 0; /* Must be disabled on the sender. */
1367:
1368: if (always_checksum
1369: && (log_format_has(stdout_format, 'C')
1370: || log_format_has(logfile_format, 'C')))
1371: sender_keeps_checksum = 1;
1372:
1373: if (protocol_version >= 30)
1374: io_start_multiplex_out(f_out);
1375: else
1376: io_start_buffering_out(f_out);
1377: if (protocol_version >= 31 || (!filesfrom_host && protocol_version >= 23))
1378: io_start_multiplex_in(f_in);
1379: else
1380: io_start_buffering_in(f_in);
1381: send_filter_list(f_out);
1382: if (filesfrom_host)
1383: filesfrom_fd = f_in;
1384:
1385: if (write_batch && !am_server)
1386: start_write_batch(f_out);
1387:
1388: become_copy_as_user();
1389:
1390: flist = send_file_list(f_out, argc, argv);
1391: if (DEBUG_GTE(FLIST, 3))
1392: rprintf(FINFO,"file list sent\n");
1393:
1394: if (protocol_version < 31 && filesfrom_host && protocol_version >= 23)
1395: io_start_multiplex_in(f_in);
1396:
1397: io_flush(NORMAL_FLUSH);
1398: send_files(f_in, f_out);
1399: io_flush(FULL_FLUSH);
1400: handle_stats(-1);
1401: if (protocol_version >= 24)
1402: read_final_goodbye(f_in, f_out);
1403: if (pid != -1) {
1404: if (DEBUG_GTE(EXIT, 2))
1405: rprintf(FINFO,"client_run waiting on %d\n", (int) pid);
1406: io_flush(FULL_FLUSH);
1407: wait_process_with_flush(pid, &exit_code);
1408: }
1409: output_summary();
1410: io_flush(FULL_FLUSH);
1411: exit_cleanup(exit_code);
1412: }
1413:
1414: if (!read_batch) {
1415: if (protocol_version >= 23)
1416: io_start_multiplex_in(f_in);
1417: if (need_messages_from_generator)
1418: io_start_multiplex_out(f_out);
1419: else
1420: io_start_buffering_out(f_out);
1421: }
1422:
1423: become_copy_as_user();
1424:
1425: send_filter_list(read_batch ? -1 : f_out);
1426:
1427: if (filesfrom_fd >= 0) {
1428: start_filesfrom_forwarding(filesfrom_fd);
1429: filesfrom_fd = -1;
1430: }
1431:
1432: if (write_batch && !am_server)
1433: start_write_batch(f_in);
1434: flist = recv_file_list(f_in, -1);
1435: if (inc_recurse && file_total == 1)
1436: recv_additional_file_list(f_in);
1437:
1438: if (flist && flist->used > 0) {
1439: local_name = get_local_name(flist, argv[0]);
1440:
1441: check_alt_basis_dirs();
1442:
1443: exit_code2 = do_recv(f_in, f_out, local_name);
1444: } else {
1445: handle_stats(-1);
1446: output_summary();
1447: }
1448:
1449: if (pid != -1) {
1450: if (DEBUG_GTE(RECV, 1))
1451: rprintf(FINFO,"client_run2 waiting on %d\n", (int) pid);
1452: io_flush(FULL_FLUSH);
1453: wait_process_with_flush(pid, &exit_code);
1454: }
1455:
1456: return MAX(exit_code, exit_code2);
1457: }
1458:
1459: static void dup_argv(char *argv[])
1460: {
1461: int i;
1462:
1463: for (i = 0; argv[i]; i++)
1464: argv[i] = strdup(argv[i]);
1465: }
1466:
1467:
1468: /* Start a client for either type of remote connection. Work out
1469: * whether the arguments request a remote shell or rsyncd connection,
1470: * and call the appropriate connection function, then run_client.
1471: *
1472: * Calls either start_socket_client (for sockets) or do_cmd and
1473: * client_run (for ssh). */
1474: static int start_client(int argc, char *argv[])
1475: {
1476: char *p, *shell_machine = NULL, *shell_user = NULL;
1477: char **remote_argv;
1478: int remote_argc, env_port = rsync_port;
1479: int f_in, f_out;
1480: int ret;
1481: pid_t pid;
1482:
1483: /* Don't clobber argv[] so that ps(1) can still show the right
1484: * command line. */
1485: dup_argv(argv);
1486:
1487: if (!read_batch) { /* for read_batch, NO source is specified */
1488: char *path = check_for_hostspec(argv[0], &shell_machine, &rsync_port);
1489:
1490: if (shell_machine && !shell_machine[0]) {
1491: #ifdef HAVE_LIBSLP
1492: /* User entered just rsync:// URI */
1493: if (lp_use_slp()) {
1494: print_service_list();
1495: exit_cleanup(0);
1496: }
1497: rprintf(FINFO, "SLP is disabled, cannot browse\n");
1498: exit_cleanup(RERR_SYNTAX);
1499: #else /* No SLP, die here */
1500: rprintf(FINFO, "No SLP support, cannot browse\n");
1501: exit_cleanup(RERR_SYNTAX);
1502: #endif
1503: }
1504:
1505: if (path) { /* source is remote */
1506: char *dummy_host;
1507: int dummy_port = 0;
1508: *argv = path;
1509: remote_argv = argv;
1510: remote_argc = argc;
1511: argv += argc - 1;
1512: if (argc == 1 || **argv == ':')
1513: argc = 0; /* no dest arg */
1514: else if (check_for_hostspec(*argv, &dummy_host, &dummy_port)) {
1515: rprintf(FERROR,
1516: "The source and destination cannot both be remote.\n");
1517: exit_cleanup(RERR_SYNTAX);
1518: } else {
1519: remote_argc--; /* don't count dest */
1520: argc = 1;
1521: }
1522: if (filesfrom_host && *filesfrom_host && strcmp(filesfrom_host, shell_machine) != 0) {
1523: rprintf(FERROR,
1524: "--files-from hostname is not the same as the transfer hostname\n");
1525: exit_cleanup(RERR_SYNTAX);
1526: }
1527: am_sender = 0;
1528: if (rsync_port)
1529: daemon_connection = shell_cmd ? 1 : -1;
1530: } else { /* source is local, check dest arg */
1531: am_sender = 1;
1532:
1533: if (argc > 1) {
1534: p = argv[--argc];
1535: remote_argv = argv + argc;
1536: } else {
1537: static char *dotarg[1] = { "." };
1538: p = dotarg[0];
1539: remote_argv = dotarg;
1540: }
1541: remote_argc = 1;
1542:
1543: path = check_for_hostspec(p, &shell_machine, &rsync_port);
1544: if (path && filesfrom_host && *filesfrom_host && strcmp(filesfrom_host, shell_machine) != 0) {
1545: rprintf(FERROR,
1546: "--files-from hostname is not the same as the transfer hostname\n");
1547: exit_cleanup(RERR_SYNTAX);
1548: }
1549: if (!path) { /* no hostspec found, so src & dest are local */
1550: local_server = 1;
1551: if (filesfrom_host) {
1552: rprintf(FERROR,
1553: "--files-from cannot be remote when the transfer is local\n");
1554: exit_cleanup(RERR_SYNTAX);
1555: }
1556: shell_machine = NULL;
1557: rsync_port = 0;
1558: } else { /* hostspec was found, so dest is remote */
1559: argv[argc] = path;
1560: if (rsync_port)
1561: daemon_connection = shell_cmd ? 1 : -1;
1562: }
1563: }
1564: } else { /* read_batch */
1565: local_server = 1;
1566: if (check_for_hostspec(argv[argc-1], &shell_machine, &rsync_port)) {
1567: rprintf(FERROR, "remote destination is not allowed with --read-batch\n");
1568: exit_cleanup(RERR_SYNTAX);
1569: }
1570: remote_argv = argv += argc - 1;
1571: remote_argc = argc = 1;
1572: rsync_port = 0;
1573: }
1574:
1575: if (!rsync_port && remote_argc && !**remote_argv) /* Turn an empty arg into a dot dir. */
1576: *remote_argv = ".";
1577:
1578: if (am_sender) {
1579: char *dummy_host;
1580: int dummy_port = rsync_port;
1581: int i;
1582: if (!argv[0][0])
1583: goto invalid_empty;
1584: /* For local source, extra source args must not have hostspec. */
1585: for (i = 1; i < argc; i++) {
1586: if (!argv[i][0]) {
1587: invalid_empty:
1588: rprintf(FERROR, "Empty source arg specified.\n");
1589: exit_cleanup(RERR_SYNTAX);
1590: }
1591: if (check_for_hostspec(argv[i], &dummy_host, &dummy_port)) {
1592: rprintf(FERROR, "Unexpected remote arg: %s\n", argv[i]);
1593: exit_cleanup(RERR_SYNTAX);
1594: }
1595: }
1596: } else {
1597: char *dummy_host;
1598: int dummy_port = rsync_port;
1599: int i;
1600: /* For remote source, any extra source args must have either
1601: * the same hostname or an empty hostname. */
1602: for (i = 1; i < remote_argc; i++) {
1603: char *arg = check_for_hostspec(remote_argv[i], &dummy_host, &dummy_port);
1604: if (!arg) {
1605: rprintf(FERROR, "Unexpected local arg: %s\n", remote_argv[i]);
1606: rprintf(FERROR, "If arg is a remote file/dir, prefix it with a colon (:).\n");
1607: exit_cleanup(RERR_SYNTAX);
1608: }
1609: if (*dummy_host && strcmp(dummy_host, shell_machine) != 0) {
1610: rprintf(FERROR, "All source args must come from the same machine.\n");
1611: exit_cleanup(RERR_SYNTAX);
1612: }
1613: if (rsync_port != dummy_port) {
1614: if (!rsync_port || !dummy_port)
1615: rprintf(FERROR, "All source args must use the same hostspec format.\n");
1616: else
1617: rprintf(FERROR, "All source args must use the same port number.\n");
1618: exit_cleanup(RERR_SYNTAX);
1619: }
1620: if (!rsync_port && !*arg) /* Turn an empty arg into a dot dir. */
1621: arg = ".";
1622: remote_argv[i] = arg;
1623: }
1624: }
1625:
1626: if (rsync_port < 0)
1627: rsync_port = RSYNC_PORT;
1628: else
1629: env_port = rsync_port;
1630:
1631: if (db_config)
1632: db_read_config(FERROR, db_config);
1633:
1634: if (daemon_connection < 0)
1635: return start_socket_client(shell_machine, remote_argc, remote_argv, argc, argv);
1636:
1637: if (password_file && !daemon_connection) {
1638: rprintf(FERROR, "The --password-file option may only be "
1639: "used when accessing an rsync daemon.\n");
1640: exit_cleanup(RERR_SYNTAX);
1641: }
1642:
1643: if (connect_timeout) {
1644: rprintf(FERROR, "The --contimeout option may only be "
1645: "used when connecting to an rsync daemon.\n");
1646: exit_cleanup(RERR_SYNTAX);
1647: }
1648:
1649: if (shell_machine) {
1650: p = strrchr(shell_machine,'@');
1651: if (p) {
1652: *p = 0;
1653: shell_user = shell_machine;
1654: shell_machine = p+1;
1655: }
1656: }
1657:
1658: if (DEBUG_GTE(CMD, 2)) {
1659: rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
1660: NS(shell_cmd), NS(shell_machine), NS(shell_user),
1661: NS(remote_argv[0]));
1662: }
1663:
1664: #ifdef HAVE_PUTENV
1665: if (daemon_connection)
1666: set_env_num("RSYNC_PORT", env_port);
1667: #endif
1668:
1669: pid = do_cmd(shell_cmd, shell_machine, shell_user, remote_argv, remote_argc, &f_in, &f_out);
1670:
1671: /* if we're running an rsync server on the remote host over a
1672: * remote shell command, we need to do the RSYNCD protocol first */
1673: if (daemon_connection) {
1674: int tmpret;
1675: tmpret = start_inband_exchange(f_in, f_out, shell_user, shell_machine, remote_argc, remote_argv);
1676: if (tmpret < 0)
1677: return tmpret;
1678: }
1679:
1680: ret = client_run(f_in, f_out, pid, argc, argv);
1681:
1682: fflush(stdout);
1683: fflush(stderr);
1684:
1685: return ret;
1686: }
1687:
1688:
1689: static void sigusr1_handler(UNUSED(int val))
1690: {
1691: called_from_signal_handler = 1;
1692: exit_cleanup(RERR_SIGNAL1);
1693: }
1694:
1695: static void sigusr2_handler(UNUSED(int val))
1696: {
1697: if (!am_server)
1698: output_summary();
1699: close_all();
1700: if (got_xfer_error)
1701: _exit(RERR_PARTIAL);
1702: _exit(0);
1703: }
1704:
1705: #if defined SIGINFO || defined SIGVTALRM
1706: static void siginfo_handler(UNUSED(int val))
1707: {
1708: if (!am_server && !INFO_GTE(PROGRESS, 1))
1709: want_progress_now = True;
1710: }
1711: #endif
1712:
1713: void remember_children(UNUSED(int val))
1714: {
1715: #ifdef WNOHANG
1716: int cnt, status;
1717: pid_t pid;
1718: /* An empty waitpid() loop was put here by Tridge and we could never
1719: * get him to explain why he put it in, so rather than taking it
1720: * out we're instead saving the child exit statuses for later use.
1721: * The waitpid() loop presumably eliminates all possibility of leaving
1722: * zombie children, maybe that's why he did it. */
1723: while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
1724: /* save the child's exit status */
1725: for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) {
1726: if (pid_stat_table[cnt].pid == 0) {
1727: pid_stat_table[cnt].pid = pid;
1728: pid_stat_table[cnt].status = status;
1729: break;
1730: }
1731: }
1732: if (WIFSIGNALED(status)) {
1733: rprintf(FLOG,
1734: "rsync error: (1) Child proccess has unexpectedly died with signal %d\n",
1735: WTERMSIG(status));
1736: } else if (WIFEXITED(status) && WEXITSTATUS(status) == RERR_WECRASHED) {
1737: rprintf(FLOG,
1738: "rsync error: (1) Child proccess has CRASHED.\n");
1739: }
1740: }
1741: #endif
1742: #ifndef HAVE_SIGACTION
1743: signal(SIGCHLD, remember_children);
1744: #endif
1745: }
1746:
1747:
1748: /**
1749: * This routine catches signals and tries to send them to gdb.
1750: *
1751: * Because it's called from inside a signal handler it ought not to
1752: * use too many library routines.
1753: *
1754: * @todo Perhaps use "screen -X" instead/as well, to help people
1755: * debugging without easy access to X. Perhaps use an environment
1756: * variable, or just call a script?
1757: *
1758: * @todo The /proc/ magic probably only works on Linux (and
1759: * Solaris?) Can we be more portable?
1760: **/
1761: #ifdef MAINTAINER_MODE
1762: const char *get_panic_action(void)
1763: {
1764: const char *cmd_fmt = getenv("RSYNC_PANIC_ACTION");
1765:
1766: if (cmd_fmt)
1767: return cmd_fmt;
1768: return "xterm -display :0 -T Panic -n Panic -e gdb /proc/%d/exe %d";
1769: }
1770:
1771:
1772: /**
1773: * Handle a fatal signal by launching a debugger, controlled by $RSYNC_PANIC_ACTION.
1774: *
1775: * This signal handler is only installed if we were configured with
1776: * --enable-maintainer-mode. Perhaps it should always be on and we
1777: * should just look at the environment variable, but I'm a bit leery
1778: * of a signal sending us into a busy loop.
1779: **/
1780: static void rsync_panic_handler(UNUSED(int whatsig))
1781: {
1782: char cmd_buf[300];
1783: int ret, pid_int = getpid();
1784:
1785: snprintf(cmd_buf, sizeof cmd_buf, get_panic_action(), pid_int, pid_int);
1786:
1787: /* Unless we failed to execute gdb, we allow the process to
1788: * continue. I'm not sure if that's right. */
1789: ret = shell_exec(cmd_buf);
1790: if (ret)
1791: _exit(ret);
1792: }
1793: #endif
1794:
1795: static void rsync_crash_handler(UNUSED(int whatsig))
1796: {
1797: log_exit(RERR_WECRASHED, __FILE__, __LINE__);
1798: logfile_close();
1799: _exit(RERR_WECRASHED);
1800: }
1801:
1802: int main(int argc,char *argv[])
1803: {
1804: int ret;
1805:
1806: raw_argc = argc;
1807: raw_argv = argv;
1808:
1809: #ifdef HAVE_SIGACTION
1810: # ifdef HAVE_SIGPROCMASK
1811: sigset_t sigmask;
1812:
1813: sigemptyset(&sigmask);
1814: # endif
1815: sigact.sa_flags = SA_NOCLDSTOP;
1816: #endif
1817: SIGACTMASK(SIGUSR1, sigusr1_handler);
1818: SIGACTMASK(SIGUSR2, sigusr2_handler);
1819: SIGACTMASK(SIGCHLD, remember_children);
1820: #ifdef MAINTAINER_MODE
1821: SIGACTMASK(SIGSEGV, rsync_panic_handler);
1822: SIGACTMASK(SIGFPE, rsync_panic_handler);
1823: SIGACTMASK(SIGABRT, rsync_panic_handler);
1824: SIGACTMASK(SIGBUS, rsync_panic_handler);
1825: #else
1826: SIGACTMASK(SIGSEGV, rsync_crash_handler);
1827: SIGACTMASK(SIGFPE, rsync_crash_handler);
1828: SIGACTMASK(SIGABRT, rsync_crash_handler);
1829: SIGACTMASK(SIGBUS, rsync_crash_handler);
1830: #endif
1831: #ifdef SIGINFO
1832: SIGACTMASK(SIGINFO, siginfo_handler);
1833: #endif
1834: #ifdef SIGVTALRM
1835: SIGACTMASK(SIGVTALRM, siginfo_handler);
1836: #endif
1837:
1838: starttime = time(NULL);
1839: our_uid = MY_UID();
1840: our_gid = MY_GID();
1841: am_root = our_uid == ROOT_UID;
1842:
1843: memset(&stats, 0, sizeof(stats));
1844:
1845: /* Even a non-daemon runs needs the default config values to be set, e.g.
1846: * lp_dont_compress() is queried when no --skip-compress option is set. */
1847: reset_daemon_vars();
1848:
1849: if (argc < 2) {
1850: usage(FERROR);
1851: exit_cleanup(RERR_SYNTAX);
1852: }
1853:
1854: /* Get the umask for use in permission calculations. We no longer set
1855: * it to zero; that is ugly and pointless now that all the callers that
1856: * relied on it have been reeducated to work with default ACLs. */
1857: umask(orig_umask = umask(0));
1858:
1859: #if defined CONFIG_LOCALE && defined HAVE_SETLOCALE
1860: setlocale(LC_CTYPE, "");
1861: #endif
1862:
1863: if (!parse_arguments(&argc, (const char ***) &argv)) {
1864: option_error();
1865: exit_cleanup(RERR_SYNTAX);
1866: }
1867: if (write_batch
1868: && poptDupArgv(argc, (const char **)argv, &cooked_argc, (const char ***)&cooked_argv) != 0)
1869: out_of_memory("main");
1870:
1871: SIGACTMASK(SIGINT, sig_int);
1872: SIGACTMASK(SIGHUP, sig_int);
1873: SIGACTMASK(SIGTERM, sig_int);
1874: #if defined HAVE_SIGACTION && HAVE_SIGPROCMASK
1875: sigprocmask(SIG_UNBLOCK, &sigmask, NULL);
1876: #endif
1877:
1878: /* Ignore SIGPIPE; we consistently check error codes and will
1879: * see the EPIPE. */
1880: SIGACTION(SIGPIPE, SIG_IGN);
1881: #ifdef SIGXFSZ
1882: SIGACTION(SIGXFSZ, SIG_IGN);
1883: #endif
1884:
1885: /* Initialize change_dir() here because on some old systems getcwd
1886: * (implemented by forking "pwd" and reading its output) doesn't
1887: * work when there are other child processes. Also, on all systems
1888: * that implement getcwd that way "pwd" can't be found after chroot. */
1889: change_dir(NULL, CD_NORMAL);
1890:
1891: if ((write_batch || read_batch) && !am_server) {
1892: open_batch_files(); /* sets batch_fd */
1893: if (read_batch)
1894: read_stream_flags(batch_fd);
1895: else
1896: write_stream_flags(batch_fd);
1897: }
1898: if (write_batch < 0)
1899: dry_run = 1;
1900:
1901: if (am_server) {
1902: #ifdef ICONV_CONST
1903: setup_iconv();
1904: #endif
1905: } else if (am_daemon)
1906: return daemon_main();
1907:
1908: if (am_server && protect_args) {
1909: char buf[MAXPATHLEN];
1910: protect_args = 2;
1911: read_args(STDIN_FILENO, NULL, buf, sizeof buf, 1, &argv, &argc, NULL);
1912: if (!parse_arguments(&argc, (const char ***) &argv)) {
1913: option_error();
1914: exit_cleanup(RERR_SYNTAX);
1915: }
1916: }
1917:
1918: if (argc < 1) {
1919: usage(FERROR);
1920: exit_cleanup(RERR_SYNTAX);
1921: }
1922:
1923: if (am_server) {
1924: set_nonblocking(STDIN_FILENO);
1925: set_nonblocking(STDOUT_FILENO);
1926: if (am_daemon)
1927: return start_daemon(STDIN_FILENO, STDOUT_FILENO);
1928: start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
1929: }
1930:
1931: ret = start_client(argc, argv);
1932: if (ret == -1)
1933: exit_cleanup(RERR_STARTCLIENT);
1934: else
1935: exit_cleanup(ret);
1936:
1937: return ret;
1938: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync