main.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1996
   3    Copyright (C) Paul Mackerras 1996
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include "rsync.h"
  21
  22 time_t starttime = 0;
  23
  24 struct stats stats;
  25
  26 extern int verbose;
  27
  28 static void report(int f)
  29 {
  30         time_t t = time(NULL);
  31         extern int am_server;
  32         extern int am_sender;
  33         extern int am_daemon;
  34         extern int do_stats;
  35         extern int remote_version;
  36         int send_stats;
  37
  38         if (am_daemon) {
  39                 log_exit(0, __FILE__, __LINE__);
  40                 if (f == -1 || !am_sender) return;
  41         }
  42
  43         send_stats = verbose || (remote_version >= 20);
  44         if (am_server) {
  45                 if (am_sender && send_stats) {
  46                         int64 w;
  47                         /* store total_written in a temporary
  48                             because write_longint changes it */
  49                         w = stats.total_written;
  50                         write_longint(f,stats.total_read);
  51                         write_longint(f,w);
  52                         write_longint(f,stats.total_size);
  53                 }
  54                 return;
  55         }
  56
  57         /* this is the client */
  58
  59         if (!am_sender && send_stats) {
  60                 int64 r;
  61                 stats.total_written = read_longint(f);
  62                 /* store total_read in a temporary, read_longint changes it */
  63                 r = read_longint(f);
  64                 stats.total_size = read_longint(f);
  65                 stats.total_read = r;
  66         }
  67
  68         if (do_stats) {
  69                 if (!am_sender && !send_stats) {
  70                     /* missing the bytes written by the generator */
  71                     rprintf(FINFO, "\nCannot show stats as receiver because remote protocol version is less than 20\n");
  72                     rprintf(FINFO, "Use --stats -v to show stats\n");
  73                     return;
  74                 }
  75                 rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
  76                 rprintf(FINFO,"Number of files transferred: %d\n",
  77                        stats.num_transferred_files);
  78                 rprintf(FINFO,"Total file size: %.0f bytes\n",
  79                        (double)stats.total_size);
  80                 rprintf(FINFO,"Total transferred file size: %.0f bytes\n",
  81                        (double)stats.total_transferred_size);
  82                 rprintf(FINFO,"Literal data: %.0f bytes\n",
  83                        (double)stats.literal_data);
  84                 rprintf(FINFO,"Matched data: %.0f bytes\n",
  85                        (double)stats.matched_data);
  86                 rprintf(FINFO,"File list size: %d\n", stats.flist_size);
  87                 rprintf(FINFO,"Total bytes written: %.0f\n",
  88                        (double)stats.total_written);
  89                 rprintf(FINFO,"Total bytes read: %.0f\n\n",
  90                        (double)stats.total_read);
  91         }
  92
  93         if (verbose || do_stats) {
  94                 rprintf(FINFO,"wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
  95                        (double)stats.total_written,
  96                        (double)stats.total_read,
  97                        (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
  98                 rprintf(FINFO,"total size is %.0f  speedup is %.2f\n",
  99                        (double)stats.total_size,
 100                        (1.0*stats.total_size)/(stats.total_written+stats.total_read));
 101         }
 102
 103         fflush(stdout);
 104         fflush(stderr);
 105 }
 106
 107
 108 static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
 109 {
 110         char *args[100];
 111         int i,argc=0, ret;
 112         char *tok,*dir=NULL;
 113         extern int local_server;
 114         extern char *rsync_path;
 115
 116         if (!local_server) {
 117                 if (!cmd)
 118                         cmd = getenv(RSYNC_RSH_ENV);
 119                 if (!cmd)
 120                         cmd = RSYNC_RSH;
 121                 cmd = strdup(cmd);
 122                 if (!cmd)
 123                         goto oom;
 124
 125                 for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
 126                         args[argc++] = tok;
 127                 }
 128
 129 #if HAVE_REMSH
 130                 /* remsh (on HPUX) takes the arguments the other way around */
 131                 args[argc++] = machine;
 132                 if (user) {
 133                         args[argc++] = "-l";
 134                         args[argc++] = user;
 135                 }
 136 #else
 137                 if (user) {
 138                         args[argc++] = "-l";
 139                         args[argc++] = user;
 140                 }
 141                 args[argc++] = machine;
 142 #endif
 143
 144                 args[argc++] = rsync_path;
 145
 146                 server_options(args,&argc);
 147         }
 148
 149         args[argc++] = ".";
 150
 151         if (path && *path)
 152                 args[argc++] = path;
 153
 154         args[argc] = NULL;
 155
 156         if (verbose > 3) {
 157                 rprintf(FINFO,"cmd=");
 158                 for (i=0;i<argc;i++)
 159                         rprintf(FINFO,"%s ",args[i]);
 160                 rprintf(FINFO,"\n");
 161         }
 162
 163         if (local_server) {
 164                 ret = local_child(argc, args, f_in, f_out);
 165         } else {
 166                 ret = piped_child(args,f_in,f_out);
 167         }
 168
 169         if (dir) free(dir);
 170
 171         return ret;
 172
 173 oom:
 174         out_of_memory("do_cmd");
 175         return 0; /* not reached */
 176 }
 177
 178
 179
 180
 181 static char *get_local_name(struct file_list *flist,char *name)
 182 {
 183         STRUCT_STAT st;
 184         extern int orig_umask;
 185
 186         if (verbose > 2)
 187                 rprintf(FINFO,"get_local_name count=%d %s\n",
 188                         flist->count, NS(name));
 189
 190         if (!name)
 191                 return NULL;
 192
 193         if (do_stat(name,&st) == 0) {
 194                 if (S_ISDIR(st.st_mode)) {
 195                         if (!push_dir(name, 0)) {
 196                                 rprintf(FERROR,"push_dir %s : %s (1)\n",
 197                                         name,strerror(errno));
 198                                 exit_cleanup(RERR_FILESELECT);
 199                         }
 200                         return NULL;
 201                 }
 202                 if (flist->count > 1) {
 203                         rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 204                         exit_cleanup(RERR_FILESELECT);
 205                 }
 206                 return name;
 207         }
 208
 209         if (flist->count <= 1)
 210                 return name;
 211
 212         if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 213                 rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
 214                 exit_cleanup(RERR_FILEIO);
 215         } else {
 216                 if (verbose > 0)
 217                         rprintf(FINFO,"created directory %s\n",name);
 218         }
 219
 220         if (!push_dir(name, 0)) {
 221                 rprintf(FERROR,"push_dir %s : %s (2)\n",
 222                         name,strerror(errno));
 223                 exit_cleanup(RERR_FILESELECT);
 224         }
 225
 226         return NULL;
 227 }
 228
 229
 230
 231
 232 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 233 {
 234         int i;
 235         struct file_list *flist;
 236         char *dir = argv[0];
 237         extern int relative_paths;
 238         extern int recurse;
 239
 240         if (verbose > 2)
 241                 rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
 242
 243         if (!relative_paths && !push_dir(dir, 0)) {
 244                 rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
 245                 exit_cleanup(RERR_FILESELECT);
 246         }
 247         argc--;
 248         argv++;
 249
 250         if (strcmp(dir,".")) {
 251                 int l = strlen(dir);
 252                 if (strcmp(dir,"/") == 0)
 253                         l = 0;
 254                 for (i=0;i<argc;i++)
 255                         argv[i] += l+1;
 256         }
 257
 258         if (argc == 0 && recurse) {
 259                 argc=1;
 260                 argv--;
 261                 argv[0] = ".";
 262         }
 263
 264         flist = send_file_list(f_out,argc,argv);
 265         if (!flist || flist->count == 0) {
 266                 exit_cleanup(0);
 267         }
 268
 269         send_files(flist,f_out,f_in);
 270         report(f_out);
 271         io_flush();
 272         exit_cleanup(0);
 273 }
 274
 275
 276 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 277 {
 278         int pid;
 279         int status=0;
 280         int recv_pipe[2];
 281         int error_pipe[2];
 282         extern int preserve_hard_links;
 283         extern int delete_after;
 284         extern int recurse;
 285         extern int delete_mode;
 286         extern int remote_version;
 287
 288         if (preserve_hard_links)
 289                 init_hard_links(flist);
 290
 291         if (!delete_after) {
 292                 /* I moved this here from recv_files() to prevent a race condition */
 293                 if (recurse && delete_mode && !local_name && flist->count>0) {
 294                         delete_files(flist);
 295                 }
 296         }
 297
 298         if (fd_pair(recv_pipe) < 0) {
 299                 rprintf(FERROR,"pipe failed in do_recv\n");
 300                 exit_cleanup(RERR_SOCKETIO);
 301         }
 302
 303         if (fd_pair(error_pipe) < 0) {
 304                 rprintf(FERROR,"error pipe failed in do_recv\n");
 305                 exit_cleanup(RERR_SOCKETIO);
 306         }
 307
 308         io_flush();
 309
 310         if ((pid=do_fork()) == 0) {
 311                 close(recv_pipe[0]);
 312                 close(error_pipe[0]);
 313                 if (f_in != f_out) close(f_out);
 314
 315                 /* we can't let two processes write to the socket at one time */
 316                 io_multiplexing_close();
 317
 318                 /* set place to send errors */
 319                 set_error_fd(error_pipe[1]);
 320
 321                 recv_files(f_in,flist,local_name,recv_pipe[1]);
 322                 report(f_in);
 323
 324                 write_int(recv_pipe[1],1);
 325                 close(recv_pipe[1]);
 326                 io_flush();
 327                 /* finally we go to sleep until our parent kills us with
 328                    a USR2 signal */
 329                 while (1) sleep(60);
 330         }
 331
 332         close(recv_pipe[1]);
 333         close(error_pipe[1]);
 334         io_close_input(f_in);
 335         if (f_in != f_out) close(f_in);
 336
 337         io_start_buffering(f_out);
 338
 339         io_set_error_fd(error_pipe[0]);
 340
 341         generate_files(f_out,flist,local_name,recv_pipe[0]);
 342
 343         read_int(recv_pipe[0]);
 344         close(recv_pipe[0]);
 345         if (remote_version >= 24) {
 346                 /* send a final goodbye message */
 347                 write_int(f_out, -1);
 348         }
 349         io_flush();
 350
 351         kill(pid, SIGUSR2);
 352         wait_process(pid, &status);
 353         return status;
 354 }
 355
 356
 357 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 358 {
 359         int status;
 360         struct file_list *flist;
 361         char *local_name=NULL;
 362         char *dir = NULL;
 363         extern int delete_mode;
 364         extern int delete_excluded;
 365         extern int am_daemon;
 366         extern int module_id;
 367         extern int am_sender;
 368
 369         if (verbose > 2)
 370                 rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
 371
 372         if (am_daemon && lp_read_only(module_id) && !am_sender) {
 373                 rprintf(FERROR,"ERROR: module is read only\n");
 374                 exit_cleanup(RERR_SYNTAX);
 375                 return;
 376         }
 377
 378
 379         if (argc > 0) {
 380                 dir = argv[0];
 381                 argc--;
 382                 argv++;
 383                 if (!am_daemon && !push_dir(dir, 0)) {
 384                         rprintf(FERROR,"push_dir %s : %s (4)\n",
 385                                 dir,strerror(errno));
 386                         exit_cleanup(RERR_FILESELECT);
 387                 }
 388         }
 389
 390         if (delete_mode && !delete_excluded)
 391                 recv_exclude_list(f_in);
 392
 393         flist = recv_file_list(f_in);
 394         if (!flist) {
 395                 rprintf(FERROR,"server_recv: recv_file_list error\n");
 396                 exit_cleanup(RERR_FILESELECT);
 397         }
 398
 399         if (argc > 0) {
 400                 if (strcmp(dir,".")) {
 401                         argv[0] += strlen(dir);
 402                         if (argv[0][0] == '/') argv[0]++;
 403                 }
 404                 local_name = get_local_name(flist,argv[0]);
 405         }
 406
 407         status = do_recv(f_in,f_out,flist,local_name);
 408         exit_cleanup(status);
 409 }
 410
 411
 412 void start_server(int f_in, int f_out, int argc, char *argv[])
 413 {
 414         extern int cvs_exclude;
 415         extern int am_sender;
 416         extern int remote_version;
 417
 418         setup_protocol(f_out, f_in);
 419
 420         if (remote_version >= 23)
 421                 io_start_multiplex_out(f_out);
 422
 423         if (am_sender) {
 424                 recv_exclude_list(f_in);
 425                 if (cvs_exclude)
 426                         add_cvs_excludes();
 427                 do_server_sender(f_in, f_out, argc, argv);
 428         } else {
 429                 do_server_recv(f_in, f_out, argc, argv);
 430         }
 431         exit_cleanup(0);
 432 }
 433
 434 int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 435 {
 436         struct file_list *flist;
 437         int status = 0, status2 = 0;
 438         char *local_name = NULL;
 439         extern int am_sender;
 440         extern int list_only;
 441         extern int remote_version;
 442
 443         setup_protocol(f_out,f_in);
 444
 445         if (remote_version >= 23)
 446                 io_start_multiplex_in(f_in);
 447
 448         if (am_sender) {
 449                 extern int cvs_exclude;
 450                 extern int delete_mode;
 451                 extern int delete_excluded;
 452                 if (cvs_exclude)
 453                         add_cvs_excludes();
 454                 if (delete_mode && !delete_excluded)
 455                         send_exclude_list(f_out);
 456                 flist = send_file_list(f_out,argc,argv);
 457                 if (verbose > 3)
 458                         rprintf(FINFO,"file list sent\n");
 459
 460                 send_files(flist,f_out,f_in);
 461                 if (pid != -1) {
 462                         if (verbose > 3)
 463                                 rprintf(FINFO,"client_run waiting on %d\n",pid);
 464                         io_flush();
 465                         wait_process(pid, &status);
 466                 }
 467                 report(-1);
 468                 if (remote_version >= 24) {
 469                         /* final goodbye message */
 470                         read_int(f_in);
 471                 }
 472                 exit_cleanup(status);
 473         }
 474
 475         if (argc == 0) list_only = 1;
 476
 477         send_exclude_list(f_out);
 478
 479         flist = recv_file_list(f_in);
 480         if (!flist || flist->count == 0) {
 481                 rprintf(FINFO,"client: nothing to do\n");
 482                 exit_cleanup(0);
 483         }
 484
 485         local_name = get_local_name(flist,argv[0]);
 486
 487         status2 = do_recv(f_in,f_out,flist,local_name);
 488
 489         if (pid != -1) {
 490                 if (verbose > 3)
 491                         rprintf(FINFO,"client_run2 waiting on %d\n",pid);
 492                 io_flush();
 493                 wait_process(pid, &status);
 494         }
 495
 496         return status | status2;
 497 }
 498
 499 static char *find_colon(char *s)
 500 {
 501         char *p, *p2;
 502
 503         p = strchr(s,':');
 504         if (!p) return NULL;
 505
 506         /* now check to see if there is a / in the string before the : - if there is then
 507            discard the colon on the assumption that the : is part of a filename */
 508         p2 = strchr(s,'/');
 509         if (p2 && p2 < p) return NULL;
 510
 511         return p;
 512 }
 513
 514 static int start_client(int argc, char *argv[])
 515 {
 516         char *p;
 517         char *shell_machine = NULL;
 518         char *shell_path = NULL;
 519         char *shell_user = NULL;
 520         int pid, ret;
 521         int f_in,f_out;
 522         extern int local_server;
 523         extern int am_sender;
 524         extern char *shell_cmd;
 525         extern int rsync_port;
 526
 527         if (strncasecmp(URL_PREFIX, argv[0], strlen(URL_PREFIX)) == 0) {
 528                 char *host, *path;
 529
 530                 host = argv[0] + strlen(URL_PREFIX);
 531                 p = strchr(host,'/');
 532                 if (p) {
 533                         *p = 0;
 534                         path = p+1;
 535                 } else {
 536                         path="";
 537                 }
 538                 p = strchr(host,':');
 539                 if (p) {
 540                         rsync_port = atoi(p+1);
 541                         *p = 0;
 542                 }
 543                 return start_socket_client(host, path, argc-1, argv+1);
 544         }
 545
 546         p = find_colon(argv[0]);
 547
 548         if (p) {
 549                 if (p[1] == ':') {
 550                         *p = 0;
 551                         return start_socket_client(argv[0], p+2, argc-1, argv+1);
 552                 }
 553
 554                 if (argc < 1) {
 555                         usage(FERROR);
 556                         exit_cleanup(RERR_SYNTAX);
 557                 }
 558
 559                 am_sender = 0;
 560                 *p = 0;
 561                 shell_machine = argv[0];
 562                 shell_path = p+1;
 563                 argc--;
 564                 argv++;
 565         } else {
 566                 am_sender = 1;
 567
 568                 p = find_colon(argv[argc-1]);
 569                 if (!p) {
 570                         local_server = 1;
 571                 } else if (p[1] == ':') {
 572                         *p = 0;
 573                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
 574                 }
 575
 576                 if (argc < 2) {
 577                         usage(FERROR);
 578                         exit_cleanup(RERR_SYNTAX);
 579                 }
 580
 581                 if (local_server) {
 582                         shell_machine = NULL;
 583                         shell_path = argv[argc-1];
 584                 } else {
 585                         *p = 0;
 586                         shell_machine = argv[argc-1];
 587                         shell_path = p+1;
 588                 }
 589                 argc--;
 590         }
 591
 592         if (shell_machine) {
 593                 p = strchr(shell_machine,'@');
 594                 if (p) {
 595                         *p = 0;
 596                         shell_user = shell_machine;
 597                         shell_machine = p+1;
 598                 }
 599         }
 600
 601         if (verbose > 3) {
 602                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 603                         shell_cmd?shell_cmd:"",
 604                         shell_machine?shell_machine:"",
 605                         shell_user?shell_user:"",
 606                         shell_path?shell_path:"");
 607         }
 608
 609         if (!am_sender && argc > 1) {
 610                 usage(FERROR);
 611                 exit_cleanup(RERR_SYNTAX);
 612         }
 613
 614         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 615
 616         ret = client_run(f_in, f_out, pid, argc, argv);
 617
 618         fflush(stdout);
 619         fflush(stderr);
 620
 621         return ret;
 622 }
 623
 624
 625 static RETSIGTYPE sigusr1_handler(int val) {
 626         exit_cleanup(RERR_SIGNAL);
 627 }
 628
 629 static RETSIGTYPE sigusr2_handler(int val) {
 630         _exit(0);
 631 }
 632
 633 int main(int argc,char *argv[])
 634 {
 635         extern int am_root;
 636         extern int orig_umask;
 637         extern int dry_run;
 638         extern int am_daemon;
 639         extern int am_server;
 640
 641         signal(SIGUSR1, sigusr1_handler);
 642         signal(SIGUSR2, sigusr2_handler);
 643
 644         starttime = time(NULL);
 645         am_root = (getuid() == 0);
 646
 647         memset(&stats, 0, sizeof(stats));
 648
 649         if (argc < 2) {
 650                 usage(FERROR);
 651                 exit_cleanup(RERR_SYNTAX);
 652         }
 653
 654         /* we set a 0 umask so that correct file permissions can be
 655            carried across */
 656         orig_umask = (int)umask(0);
 657
 658         if (!parse_arguments(argc, argv, 1)) {
 659                 exit_cleanup(RERR_SYNTAX);
 660         }
 661
 662         argc -= optind;
 663         argv += optind;
 664         optind = 0;
 665
 666         signal(SIGCHLD,SIG_IGN);
 667         signal(SIGINT,SIGNAL_CAST sig_int);
 668         signal(SIGPIPE,SIGNAL_CAST sig_int);
 669         signal(SIGHUP,SIGNAL_CAST sig_int);
 670         signal(SIGTERM,SIGNAL_CAST sig_int);
 671
 672         /* Initialize push_dir here because on some old systems getcwd
 673            (implemented by forking "pwd" and reading its output) doesn't
 674            work when there are other child processes.  Also, on all systems
 675            that implement getcwd that way "pwd" can't be found after chroot. */
 676         push_dir(NULL,0);
 677
 678         if (am_daemon) {
 679                 return daemon_main();
 680         }
 681
 682         if (argc < 1) {
 683                 usage(FERROR);
 684                 exit_cleanup(RERR_SYNTAX);
 685         }
 686
 687         if (dry_run)
 688                 verbose = MAX(verbose,1);
 689
 690 #ifndef SUPPORT_LINKS
 691         if (!am_server && preserve_links) {
 692                 rprintf(FERROR,"ERROR: symbolic links not supported\n");
 693                 exit_cleanup(RERR_UNSUPPORTED);
 694         }
 695 #endif
 696
 697         if (am_server) {
 698                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 699         }
 700
 701         return start_client(argc, argv);
 702 }
 703