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