1 /* -*- c-file-style: "linux" -*-
3 Copyright (C) 1996-2001 by Andrew Tridgell <tridge@samba.org>
4 Copyright (C) Paul Mackerras 1996
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 /****************************************************************************
31 wait for a process to exit, calling io_flush while waiting
32 ****************************************************************************/
33 void wait_process(pid_t pid, int *status)
35 while (waitpid(pid, status, WNOHANG) == 0) {
40 /* TODO: If the child exited on a signal, then log an
41 * appropriate error message. Perhaps we should also accept a
42 * message describing the purpose of the child. Also indicate
43 * this to the caller so that thhey know something went
45 *status = WEXITSTATUS(*status);
48 static void report(int f)
50 time_t t = time(NULL);
55 extern int remote_version;
59 log_exit(0, __FILE__, __LINE__);
60 if (f == -1 || !am_sender) return;
63 send_stats = verbose || (remote_version >= 20);
65 if (am_sender && send_stats) {
67 /* store total_written in a temporary
68 because write_longint changes it */
69 w = stats.total_written;
70 write_longint(f,stats.total_read);
72 write_longint(f,stats.total_size);
77 /* this is the client */
79 if (!am_sender && send_stats) {
81 stats.total_written = read_longint(f);
82 /* store total_read in a temporary, read_longint changes it */
84 stats.total_size = read_longint(f);
89 if (!am_sender && !send_stats) {
90 /* missing the bytes written by the generator */
91 rprintf(FINFO, "\nCannot show stats as receiver because remote protocol version is less than 20\n");
92 rprintf(FINFO, "Use --stats -v to show stats\n");
95 rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
96 rprintf(FINFO,"Number of files transferred: %d\n",
97 stats.num_transferred_files);
98 rprintf(FINFO,"Total file size: %.0f bytes\n",
99 (double)stats.total_size);
100 rprintf(FINFO,"Total transferred file size: %.0f bytes\n",
101 (double)stats.total_transferred_size);
102 rprintf(FINFO,"Literal data: %.0f bytes\n",
103 (double)stats.literal_data);
104 rprintf(FINFO,"Matched data: %.0f bytes\n",
105 (double)stats.matched_data);
106 rprintf(FINFO,"File list size: %d\n", stats.flist_size);
107 rprintf(FINFO,"Total bytes written: %.0f\n",
108 (double)stats.total_written);
109 rprintf(FINFO,"Total bytes read: %.0f\n\n",
110 (double)stats.total_read);
113 if (verbose || do_stats) {
114 rprintf(FINFO,"wrote %.0f bytes read %.0f bytes %.2f bytes/sec\n",
115 (double)stats.total_written,
116 (double)stats.total_read,
117 (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
118 rprintf(FINFO,"total size is %.0f speedup is %.2f\n",
119 (double)stats.total_size,
120 (1.0*stats.total_size)/(stats.total_written+stats.total_read));
128 /* Start the remote shell. cmd may be NULL to use the default. */
129 static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
135 extern int local_server;
136 extern char *rsync_path;
137 extern int blocking_io;
141 cmd = getenv(RSYNC_RSH_ENV);
148 for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
153 /* remsh (on HPUX) takes the arguments the other way around */
154 args[argc++] = machine;
164 args[argc++] = machine;
167 args[argc++] = rsync_path;
169 server_options(args,&argc);
172 if (strcmp(cmd, RSYNC_RSH) == 0) blocking_io = 1;
183 rprintf(FINFO,"cmd=");
185 rprintf(FINFO,"%s ",args[i]);
190 ret = local_child(argc, args, f_in, f_out);
192 ret = piped_child(args,f_in,f_out);
200 out_of_memory("do_cmd");
201 return 0; /* not reached */
207 static char *get_local_name(struct file_list *flist,char *name)
210 extern int orig_umask;
213 rprintf(FINFO,"get_local_name count=%d %s\n",
214 flist->count, NS(name));
219 if (do_stat(name,&st) == 0) {
220 if (S_ISDIR(st.st_mode)) {
221 if (!push_dir(name, 0)) {
222 rprintf(FERROR,"push_dir %s : %s (1)\n",
223 name,strerror(errno));
224 exit_cleanup(RERR_FILESELECT);
228 if (flist->count > 1) {
229 rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
230 exit_cleanup(RERR_FILESELECT);
235 if (flist->count <= 1)
238 if (do_mkdir(name,0777 & ~orig_umask) != 0) {
239 rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
240 exit_cleanup(RERR_FILEIO);
243 rprintf(FINFO,"created directory %s\n",name);
246 if (!push_dir(name, 0)) {
247 rprintf(FERROR,"push_dir %s : %s (2)\n",
248 name,strerror(errno));
249 exit_cleanup(RERR_FILESELECT);
258 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
261 struct file_list *flist;
263 extern int relative_paths;
265 extern int remote_version;
268 rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
270 if (!relative_paths && !push_dir(dir, 0)) {
271 rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
272 exit_cleanup(RERR_FILESELECT);
277 if (strcmp(dir,".")) {
279 if (strcmp(dir,"/") == 0)
285 if (argc == 0 && recurse) {
291 flist = send_file_list(f_out,argc,argv);
292 if (!flist || flist->count == 0) {
296 send_files(flist,f_out,f_in);
299 if (remote_version >= 24) {
300 /* final goodbye message */
308 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
314 extern int preserve_hard_links;
315 extern int delete_after;
317 extern int delete_mode;
318 extern int remote_version;
320 if (preserve_hard_links)
321 init_hard_links(flist);
324 /* I moved this here from recv_files() to prevent a race condition */
325 if (recurse && delete_mode && !local_name && flist->count>0) {
330 if (fd_pair(recv_pipe) < 0) {
331 rprintf(FERROR,"pipe failed in do_recv\n");
332 exit_cleanup(RERR_SOCKETIO);
335 if (fd_pair(error_pipe) < 0) {
336 rprintf(FERROR,"error pipe failed in do_recv\n");
337 exit_cleanup(RERR_SOCKETIO);
342 if ((pid=do_fork()) == 0) {
344 close(error_pipe[0]);
345 if (f_in != f_out) close(f_out);
347 /* we can't let two processes write to the socket at one time */
348 io_multiplexing_close();
350 /* set place to send errors */
351 set_error_fd(error_pipe[1]);
353 recv_files(f_in,flist,local_name,recv_pipe[1]);
357 write_int(recv_pipe[1],1);
360 /* finally we go to sleep until our parent kills us
361 with a USR2 signal. We sleep for a short time as on
362 some OSes a signal won't interrupt a sleep! */
363 while (1) msleep(20);
367 close(error_pipe[1]);
368 if (f_in != f_out) close(f_in);
370 io_start_buffering(f_out);
372 io_set_error_fd(error_pipe[0]);
374 generate_files(f_out,flist,local_name,recv_pipe[0]);
376 read_int(recv_pipe[0]);
378 if (remote_version >= 24) {
379 /* send a final goodbye message */
380 write_int(f_out, -1);
385 wait_process(pid, &status);
390 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
393 struct file_list *flist;
394 char *local_name=NULL;
396 extern int delete_mode;
397 extern int delete_excluded;
398 extern int am_daemon;
399 extern int module_id;
400 extern int am_sender;
403 rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
405 if (am_daemon && lp_read_only(module_id) && !am_sender) {
406 rprintf(FERROR,"ERROR: module is read only\n");
407 exit_cleanup(RERR_SYNTAX);
416 if (!am_daemon && !push_dir(dir, 0)) {
417 rprintf(FERROR,"push_dir %s : %s (4)\n",
418 dir,strerror(errno));
419 exit_cleanup(RERR_FILESELECT);
423 if (delete_mode && !delete_excluded)
424 recv_exclude_list(f_in);
426 flist = recv_file_list(f_in);
428 rprintf(FERROR,"server_recv: recv_file_list error\n");
429 exit_cleanup(RERR_FILESELECT);
433 if (strcmp(dir,".")) {
434 argv[0] += strlen(dir);
435 if (argv[0][0] == '/') argv[0]++;
437 local_name = get_local_name(flist,argv[0]);
440 status = do_recv(f_in,f_out,flist,local_name);
441 exit_cleanup(status);
445 void start_server(int f_in, int f_out, int argc, char *argv[])
447 extern int cvs_exclude;
448 extern int am_sender;
449 extern int remote_version;
451 setup_protocol(f_out, f_in);
453 set_nonblocking(f_in);
454 set_nonblocking(f_out);
456 if (remote_version >= 23)
457 io_start_multiplex_out(f_out);
460 recv_exclude_list(f_in);
463 do_server_sender(f_in, f_out, argc, argv);
465 do_server_recv(f_in, f_out, argc, argv);
472 * This is called once the connection has been negotiated. It is used
473 * for rsyncd, remote-shell, and local connections.
475 int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
477 struct file_list *flist;
478 int status = 0, status2 = 0;
479 char *local_name = NULL;
480 extern int am_sender;
481 extern int remote_version;
482 extern pid_t cleanup_child_pid;
484 cleanup_child_pid = pid;
486 set_nonblocking(f_in);
487 set_nonblocking(f_out);
489 setup_protocol(f_out,f_in);
491 if (remote_version >= 23)
492 io_start_multiplex_in(f_in);
495 extern int cvs_exclude;
496 extern int delete_mode;
497 extern int delete_excluded;
500 if (delete_mode && !delete_excluded)
501 send_exclude_list(f_out);
502 flist = send_file_list(f_out,argc,argv);
504 rprintf(FINFO,"file list sent\n");
506 send_files(flist,f_out,f_in);
507 if (remote_version >= 24) {
508 /* final goodbye message */
513 rprintf(FINFO,"client_run waiting on %d\n",pid);
515 wait_process(pid, &status);
518 exit_cleanup(status);
522 extern int list_only;
526 send_exclude_list(f_out);
528 flist = recv_file_list(f_in);
529 if (!flist || flist->count == 0) {
530 rprintf(FINFO, "client: nothing to do: "
531 "perhaps you need to specify some filenames or "
532 "the --recursive option?\n");
536 local_name = get_local_name(flist,argv[0]);
538 status2 = do_recv(f_in,f_out,flist,local_name);
542 rprintf(FINFO,"client_run2 waiting on %d\n",pid);
544 wait_process(pid, &status);
547 return MAX(status, status2);
550 static char *find_colon(char *s)
557 /* now check to see if there is a / in the string before the : - if there is then
558 discard the colon on the assumption that the : is part of a filename */
560 if (p2 && p2 < p) return NULL;
567 * Start a client for either type of remote connection. Work out
568 * whether the arguments request a remote shell or rsyncd connection,
569 * and call the appropriate connection function, then run_client.
571 static int start_client(int argc, char *argv[])
574 char *shell_machine = NULL;
575 char *shell_path = NULL;
576 char *shell_user = NULL;
580 extern int local_server;
581 extern int am_sender;
582 extern char *shell_cmd;
583 extern int rsync_port;
584 extern int whole_file;
585 char *argv0 = strdup(argv[0]);
587 if (strncasecmp(URL_PREFIX, argv0, strlen(URL_PREFIX)) == 0) {
590 host = argv0 + strlen(URL_PREFIX);
591 p = strchr(host,'/');
598 p = strchr(host,':');
600 rsync_port = atoi(p+1);
603 return start_socket_client(host, path, argc-1, argv+1);
606 p = find_colon(argv0);
611 return start_socket_client(argv0, p+2, argc-1, argv+1);
616 exit_cleanup(RERR_SYNTAX);
621 shell_machine = argv0;
628 p = find_colon(argv[argc-1]);
631 /* disable "rsync algorithm" when both sides local */
633 } else if (p[1] == ':') {
635 return start_socket_client(argv[argc-1], p+2, argc-1, argv);
640 exit_cleanup(RERR_SYNTAX);
644 shell_machine = NULL;
645 shell_path = argv[argc-1];
648 shell_machine = argv[argc-1];
655 p = strchr(shell_machine,'@');
658 shell_user = shell_machine;
664 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
665 shell_cmd?shell_cmd:"",
666 shell_machine?shell_machine:"",
667 shell_user?shell_user:"",
668 shell_path?shell_path:"");
671 if (!am_sender && argc > 1) {
673 exit_cleanup(RERR_SYNTAX);
676 if (argc == 0 && !am_sender) {
677 extern int list_only;
681 pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
683 ret = client_run(f_in, f_out, pid, argc, argv);
692 static RETSIGTYPE sigusr1_handler(int val) {
693 exit_cleanup(RERR_SIGNAL);
696 static RETSIGTYPE sigusr2_handler(int val) {
697 extern int log_got_error;
698 if (log_got_error) _exit(RERR_PARTIAL);
702 static RETSIGTYPE sigchld_handler(int val) {
704 while (waitpid(-1, NULL, WNOHANG) > 0) ;
708 int main(int argc,char *argv[])
711 extern int orig_umask;
713 extern int am_daemon;
714 extern int am_server;
717 signal(SIGUSR1, sigusr1_handler);
718 signal(SIGUSR2, sigusr2_handler);
719 signal(SIGCHLD, sigchld_handler);
721 starttime = time(NULL);
722 am_root = (getuid() == 0);
724 memset(&stats, 0, sizeof(stats));
728 exit_cleanup(RERR_SYNTAX);
731 /* we set a 0 umask so that correct file permissions can be
733 orig_umask = (int)umask(0);
735 if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
736 /* FIXME: We ought to call the same error-handling
737 * code here, rather than relying on getopt. */
739 exit_cleanup(RERR_SYNTAX);
742 signal(SIGINT,SIGNAL_CAST sig_int);
743 signal(SIGPIPE,SIGNAL_CAST sig_int);
744 signal(SIGHUP,SIGNAL_CAST sig_int);
745 signal(SIGTERM,SIGNAL_CAST sig_int);
747 /* Initialize push_dir here because on some old systems getcwd
748 (implemented by forking "pwd" and reading its output) doesn't
749 work when there are other child processes. Also, on all systems
750 that implement getcwd that way "pwd" can't be found after chroot. */
754 return daemon_main();
759 exit_cleanup(RERR_SYNTAX);
763 verbose = MAX(verbose,1);
765 #ifndef SUPPORT_LINKS
766 if (!am_server && preserve_links) {
767 rprintf(FERROR,"ERROR: symbolic links not supported\n");
768 exit_cleanup(RERR_UNSUPPORTED);
773 set_nonblocking(STDIN_FILENO);
774 set_nonblocking(STDOUT_FILENO);
775 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
778 ret = start_client(argc, argv);