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 csum_length;
  27
  28 extern int verbose;
  29
  30 static void report(int f)
  31 {
  32         time_t t = time(NULL);
  33         extern int am_server;
  34         extern int am_sender;
  35         extern int am_daemon;
  36         extern int do_stats;
  37
  38         if (am_daemon) {
  39                 syslog(LOG_INFO,"wrote %.0f bytes  read %.0f bytes  total size %.0f\n",
  40                        (double)stats.total_written,
  41                        (double)stats.total_read,
  42                        (double)stats.total_size);
  43                 if (f == -1 || !am_sender) return;
  44         }
  45
  46         if (!verbose) return;
  47
  48         if (am_server && !am_sender) return;
  49
  50         if (am_server && am_sender) {
  51                 write_longint(f,stats.total_read);
  52                 write_longint(f,stats.total_written);
  53                 write_longint(f,stats.total_size);
  54                 return;
  55         }
  56
  57         if (!am_sender) {
  58                 int64 r;
  59                 stats.total_written = read_longint(f);
  60                 r = read_longint(f);
  61                 stats.total_size = read_longint(f);
  62                 stats.total_read = r;
  63         }
  64
  65         if (do_stats) {
  66                 rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
  67                 rprintf(FINFO,"Number of files transferred: %d\n",
  68                        stats.num_transferred_files);
  69                 rprintf(FINFO,"Total file size: %.0f bytes\n",
  70                        (double)stats.total_size);
  71                 rprintf(FINFO,"Total transferred file size: %.0f bytes\n",
  72                        (double)stats.total_transferred_size);
  73                 rprintf(FINFO,"Literal data: %.0f bytes\n",
  74                        (double)stats.literal_data);
  75                 rprintf(FINFO,"Matched data: %.0f bytes\n",
  76                        (double)stats.matched_data);
  77                 rprintf(FINFO,"File list size: %d\n", stats.flist_size);
  78                 rprintf(FINFO,"Total bytes written: %.0f\n",
  79                        (double)stats.total_written);
  80                 rprintf(FINFO,"Total bytes read: %.0f\n\n",
  81                        (double)stats.total_read);
  82         }
  83
  84         rprintf(FINFO,"wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
  85                (double)stats.total_written,
  86                (double)stats.total_read,
  87                (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
  88         rprintf(FINFO,"total size is %.0f  speedup is %.2f\n",
  89                (double)stats.total_size,
  90                (1.0*stats.total_size)/(stats.total_written+stats.total_read));
  91
  92         fflush(stdout);
  93         fflush(stderr);
  94 }
  95
  96
  97 static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
  98 {
  99         char *args[100];
 100         int i,argc=0, ret;
 101         char *tok,*dir=NULL;
 102         extern int local_server;
 103         extern char *rsync_path;
 104
 105         if (!local_server) {
 106                 if (!cmd)
 107                         cmd = getenv(RSYNC_RSH_ENV);
 108                 if (!cmd)
 109                         cmd = RSYNC_RSH;
 110                 cmd = strdup(cmd);
 111                 if (!cmd)
 112                         goto oom;
 113
 114                 for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
 115                         args[argc++] = tok;
 116                 }
 117
 118 #if HAVE_REMSH
 119                 /* remsh (on HPUX) takes the arguments the other way around */
 120                 args[argc++] = machine;
 121                 if (user) {
 122                         args[argc++] = "-l";
 123                         args[argc++] = user;
 124                 }
 125 #else
 126                 if (user) {
 127                         args[argc++] = "-l";
 128                         args[argc++] = user;
 129                 }
 130                 args[argc++] = machine;
 131 #endif
 132
 133                 args[argc++] = rsync_path;
 134
 135                 server_options(args,&argc);
 136         }
 137
 138         args[argc++] = ".";
 139
 140         if (path && *path)
 141                 args[argc++] = path;
 142
 143         args[argc] = NULL;
 144
 145         if (verbose > 3) {
 146                 rprintf(FINFO,"cmd=");
 147                 for (i=0;i<argc;i++)
 148                         rprintf(FINFO,"%s ",args[i]);
 149                 rprintf(FINFO,"\n");
 150         }
 151
 152         if (local_server) {
 153                 ret = local_child(argc, args, f_in, f_out);
 154         } else {
 155                 ret = piped_child(args,f_in,f_out);
 156         }
 157
 158         if (dir) free(dir);
 159
 160         return ret;
 161
 162 oom:
 163         out_of_memory("do_cmd");
 164         return 0; /* not reached */
 165 }
 166
 167
 168
 169
 170 static char *get_local_name(struct file_list *flist,char *name)
 171 {
 172         STRUCT_STAT st;
 173         extern int orig_umask;
 174
 175         if (verbose > 2)
 176                 rprintf(FINFO,"get_local_name count=%d %s\n",
 177                         flist->count, name);
 178
 179         if (do_stat(name,&st) == 0) {
 180                 if (S_ISDIR(st.st_mode)) {
 181                         if (!push_dir(name, 0)) {
 182                                 rprintf(FERROR,"push_dir %s : %s (1)\n",
 183                                         name,strerror(errno));
 184                                 exit_cleanup(1);
 185                         }
 186                         return NULL;
 187                 }
 188                 if (flist->count > 1) {
 189                         rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 190                         exit_cleanup(1);
 191                 }
 192                 return name;
 193         }
 194
 195         if (flist->count == 1)
 196                 return name;
 197
 198         if (!name)
 199                 return NULL;
 200
 201         if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 202                 rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
 203                 exit_cleanup(1);
 204         } else {
 205                 if (verbose > 0)
 206                         rprintf(FINFO,"created directory %s\n",name);
 207         }
 208
 209         if (!push_dir(name, 0)) {
 210                 rprintf(FERROR,"push_dir %s : %s (2)\n",
 211                         name,strerror(errno));
 212                 exit_cleanup(1);
 213         }
 214
 215         return NULL;
 216 }
 217
 218
 219
 220
 221 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 222 {
 223         int i;
 224         struct file_list *flist;
 225         char *dir = argv[0];
 226         extern int relative_paths;
 227         extern int recurse;
 228
 229         if (verbose > 2)
 230                 rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
 231
 232         if (!relative_paths && !push_dir(dir, 0)) {
 233                 rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
 234                 exit_cleanup(1);
 235         }
 236         argc--;
 237         argv++;
 238
 239         if (strcmp(dir,".")) {
 240                 int l = strlen(dir);
 241                 if (strcmp(dir,"/") == 0)
 242                         l = 0;
 243                 for (i=0;i<argc;i++)
 244                         argv[i] += l+1;
 245         }
 246
 247         if (argc == 0 && recurse) {
 248                 argc=1;
 249                 argv--;
 250                 argv[0] = ".";
 251         }
 252
 253         set_nonblocking(f_out);
 254         if (f_in != f_out)
 255                 set_nonblocking(f_in);
 256
 257         flist = send_file_list(f_out,argc,argv);
 258         if (!flist || flist->count == 0) {
 259                 exit_cleanup(0);
 260         }
 261
 262         send_files(flist,f_out,f_in);
 263         report(f_out);
 264         io_flush();
 265         exit_cleanup(0);
 266 }
 267
 268
 269 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 270 {
 271         int pid;
 272         int status=0;
 273         int recv_pipe[2];
 274         extern int preserve_hard_links;
 275
 276         if (preserve_hard_links)
 277                 init_hard_links(flist);
 278
 279         if (pipe(recv_pipe) < 0) {
 280                 rprintf(FERROR,"pipe failed in do_recv\n");
 281                 exit_cleanup(1);
 282         }
 283
 284         io_flush();
 285
 286         if ((pid=do_fork()) == 0) {
 287                 close(recv_pipe[0]);
 288                 if (f_in != f_out) close(f_out);
 289
 290                 set_nonblocking(f_in);
 291                 set_nonblocking(recv_pipe[1]);
 292
 293                 recv_files(f_in,flist,local_name,recv_pipe[1]);
 294                 report(f_in);
 295
 296                 io_flush();
 297                 _exit(0);
 298         }
 299
 300         close(recv_pipe[1]);
 301         io_close_input(f_in);
 302         if (f_in != f_out) close(f_in);
 303
 304         set_nonblocking(f_out);
 305         set_nonblocking(recv_pipe[0]);
 306
 307         io_start_buffering(f_out);
 308
 309         generate_files(f_out,flist,local_name,recv_pipe[0]);
 310
 311         io_flush();
 312         waitpid(pid, &status, 0);
 313         return status;
 314 }
 315
 316
 317 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 318 {
 319         int status;
 320         struct file_list *flist;
 321         char *local_name=NULL;
 322         char *dir = NULL;
 323         extern int delete_mode;
 324         extern int am_daemon;
 325
 326         if (verbose > 2)
 327                 rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
 328
 329         if (argc > 0) {
 330                 dir = argv[0];
 331                 argc--;
 332                 argv++;
 333                 if (!am_daemon && !push_dir(dir, 0)) {
 334                         rprintf(FERROR,"push_dir %s : %s (4)\n",
 335                                 dir,strerror(errno));
 336                         exit_cleanup(1);
 337                 }
 338         }
 339
 340         if (delete_mode)
 341                 recv_exclude_list(f_in);
 342
 343         flist = recv_file_list(f_in);
 344         if (!flist || flist->count == 0) {
 345                 rprintf(FERROR,"server_recv: nothing to do\n");
 346                 exit_cleanup(1);
 347         }
 348
 349         if (argc > 0) {
 350                 if (strcmp(dir,".")) {
 351                         argv[0] += strlen(dir);
 352                         if (argv[0][0] == '/') argv[0]++;
 353                 }
 354                 local_name = get_local_name(flist,argv[0]);
 355         }
 356
 357         status = do_recv(f_in,f_out,flist,local_name);
 358         exit_cleanup(status);
 359 }
 360
 361
 362 void start_server(int f_in, int f_out, int argc, char *argv[])
 363 {
 364         extern int cvs_exclude;
 365         extern int am_sender;
 366
 367         set_nonblocking(f_out);
 368         if (f_in != f_out)
 369                 set_nonblocking(f_in);
 370
 371         setup_protocol(f_out, f_in);
 372
 373         if (am_sender) {
 374                 recv_exclude_list(f_in);
 375                 if (cvs_exclude)
 376                         add_cvs_excludes();
 377                 do_server_sender(f_in, f_out, argc, argv);
 378         } else {
 379                 do_server_recv(f_in, f_out, argc, argv);
 380         }
 381         exit_cleanup(0);
 382 }
 383
 384 int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 385 {
 386         struct file_list *flist;
 387         int status = 0, status2 = 0;
 388         char *local_name = NULL;
 389         extern int am_sender;
 390
 391         setup_protocol(f_out,f_in);
 392
 393         if (am_sender) {
 394                 extern int cvs_exclude;
 395                 extern int delete_mode;
 396                 if (cvs_exclude)
 397                         add_cvs_excludes();
 398                 if (delete_mode)
 399                         send_exclude_list(f_out);
 400                 flist = send_file_list(f_out,argc,argv);
 401                 if (verbose > 3)
 402                         rprintf(FINFO,"file list sent\n");
 403
 404                 set_nonblocking(f_out);
 405                 if (f_in != f_out)
 406                         set_nonblocking(f_in);
 407
 408                 send_files(flist,f_out,f_in);
 409                 if (pid != -1) {
 410                         if (verbose > 3)
 411                                 rprintf(FINFO,"client_run waiting on %d\n",pid);
 412                         io_flush();
 413                         waitpid(pid, &status, 0);
 414                 }
 415                 report(-1);
 416                 exit_cleanup(status);
 417         }
 418
 419         send_exclude_list(f_out);
 420
 421         flist = recv_file_list(f_in);
 422         if (!flist || flist->count == 0) {
 423                 rprintf(FINFO,"client: nothing to do\n");
 424                 exit_cleanup(0);
 425         }
 426
 427         local_name = get_local_name(flist,argv[0]);
 428
 429         status2 = do_recv(f_in,f_out,flist,local_name);
 430
 431         if (pid != -1) {
 432                 if (verbose > 3)
 433                         rprintf(FINFO,"client_run2 waiting on %d\n",pid);
 434                 io_flush();
 435                 waitpid(pid, &status, 0);
 436         }
 437
 438         return status | status2;
 439 }
 440
 441 static char *find_colon(char *s)
 442 {
 443         char *p, *p2;
 444
 445         p = strchr(s,':');
 446         if (!p) return NULL;
 447
 448         /* now check to see if there is a / in the string before the : - if there is then
 449            discard the colon on the assumption that the : is part of a filename */
 450         p2 = strchr(s,'/');
 451         if (p2 && p2 < p) return NULL;
 452
 453         return p;
 454 }
 455
 456 static int start_client(int argc, char *argv[])
 457 {
 458         char *p;
 459         char *shell_machine = NULL;
 460         char *shell_path = NULL;
 461         char *shell_user = NULL;
 462         int pid, ret;
 463         int f_in,f_out;
 464         extern int local_server;
 465         extern int am_sender;
 466         extern char *shell_cmd;
 467
 468         p = find_colon(argv[0]);
 469
 470         if (p) {
 471                 if (p[1] == ':') {
 472                         *p = 0;
 473                         return start_socket_client(argv[0], p+2, argc-1, argv+1);
 474                 }
 475
 476                 if (argc < 2) {
 477                         usage(FERROR);
 478                         exit_cleanup(1);
 479                 }
 480
 481                 am_sender = 0;
 482                 *p = 0;
 483                 shell_machine = argv[0];
 484                 shell_path = p+1;
 485                 argc--;
 486                 argv++;
 487         } else {
 488                 am_sender = 1;
 489
 490                 p = find_colon(argv[argc-1]);
 491                 if (!p) {
 492                         local_server = 1;
 493                 } else if (p[1] == ':') {
 494                         *p = 0;
 495                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
 496                 }
 497
 498                 if (argc < 2) {
 499                         usage(FERROR);
 500                         exit_cleanup(1);
 501                 }
 502
 503                 if (local_server) {
 504                         shell_machine = NULL;
 505                         shell_path = argv[argc-1];
 506                 } else {
 507                         *p = 0;
 508                         shell_machine = argv[argc-1];
 509                         shell_path = p+1;
 510                 }
 511                 argc--;
 512         }
 513
 514         if (shell_machine) {
 515                 p = strchr(shell_machine,'@');
 516                 if (p) {
 517                         *p = 0;
 518                         shell_user = shell_machine;
 519                         shell_machine = p+1;
 520                 }
 521         }
 522
 523         if (verbose > 3) {
 524                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 525                         shell_cmd?shell_cmd:"",
 526                         shell_machine?shell_machine:"",
 527                         shell_user?shell_user:"",
 528                         shell_path?shell_path:"");
 529         }
 530
 531         if (!am_sender && argc != 1) {
 532                 usage(FERROR);
 533                 exit_cleanup(1);
 534         }
 535
 536         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 537
 538         ret = client_run(f_in, f_out, pid, argc, argv);
 539
 540         fflush(stdout);
 541         fflush(stderr);
 542
 543         return ret;
 544 }
 545
 546
 547 static RETSIGTYPE sigusr1_handler(int val) {
 548         exit_cleanup(1);
 549 }
 550
 551 int main(int argc,char *argv[])
 552 {
 553         extern int am_root;
 554         extern int orig_umask;
 555         extern int dry_run;
 556         extern int am_daemon;
 557         extern int am_server;
 558
 559         signal(SIGUSR1, sigusr1_handler);
 560
 561         starttime = time(NULL);
 562         am_root = (getuid() == 0);
 563
 564         memset(&stats, 0, sizeof(stats));
 565
 566         if (argc < 2) {
 567                 usage(FERROR);
 568                 exit_cleanup(1);
 569         }
 570
 571         /* we set a 0 umask so that correct file permissions can be
 572            carried across */
 573         orig_umask = (int)umask(0);
 574
 575         if (!parse_arguments(argc, argv)) {
 576                 exit_cleanup(1);
 577         }
 578
 579         argc -= optind;
 580         argv += optind;
 581         optind = 0;
 582
 583         signal(SIGCHLD,SIG_IGN);
 584         signal(SIGINT,SIGNAL_CAST sig_int);
 585         signal(SIGPIPE,SIGNAL_CAST sig_int);
 586         signal(SIGHUP,SIGNAL_CAST sig_int);
 587         signal(SIGTERM,SIGNAL_CAST sig_int);
 588
 589         if (am_daemon) {
 590                 return daemon_main();
 591         }
 592
 593         if (argc < 1) {
 594                 usage(FERROR);
 595                 exit_cleanup(1);
 596         }
 597
 598         if (dry_run)
 599                 verbose = MAX(verbose,1);
 600
 601 #ifndef SUPPORT_LINKS
 602         if (!am_server && preserve_links) {
 603                 rprintf(FERROR,"ERROR: symbolic links not supported\n");
 604                 exit_cleanup(1);
 605         }
 606 #endif
 607
 608         if (am_server) {
 609                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 610         }
 611
 612         return start_client(argc, argv);
 613 }
 614