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                 printf("\nNumber of files: %d\n", stats.num_files);
  67                 printf("Number of files transferred: %d\n",
  68                        stats.num_transferred_files);
  69                 printf("Total file size: %.0f bytes\n",
  70                        (double)stats.total_size);
  71                 printf("Total transferred file size: %.0f bytes\n",
  72                        (double)stats.total_transferred_size);
  73                 printf("Literal data: %.0f bytes\n",
  74                        (double)stats.literal_data);
  75                 printf("Matched data: %.0f bytes\n",
  76                        (double)stats.matched_data);
  77                 printf("File list size: %d\n", stats.flist_size);
  78                 printf("Total bytes written: %.0f\n",
  79                        (double)stats.total_written);
  80                 printf("Total bytes read: %.0f\n\n",
  81                        (double)stats.total_read);
  82         }
  83
  84         printf("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         printf("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
  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 (do_stat(name,&st) == 0) {
 173                 if (S_ISDIR(st.st_mode)) {
 174                         if (!push_dir(name, 0)) {
 175                                 rprintf(FERROR,"push_dir %s : %s (1)\n",
 176                                         name,strerror(errno));
 177                                 exit_cleanup(1);
 178                         }
 179                         return NULL;
 180                 }
 181                 if (flist->count > 1) {
 182                         rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 183                         exit_cleanup(1);
 184                 }
 185                 return name;
 186         }
 187
 188         if (flist->count == 1)
 189                 return name;
 190
 191         if (!name)
 192                 return NULL;
 193
 194         if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 195                 rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
 196                 exit_cleanup(1);
 197         } else {
 198                 rprintf(FINFO,"created directory %s\n",name);
 199         }
 200
 201         if (!push_dir(name, 0)) {
 202                 rprintf(FERROR,"push_dir %s : %s (2)\n",
 203                         name,strerror(errno));
 204                 exit_cleanup(1);
 205         }
 206
 207         return NULL;
 208 }
 209
 210
 211
 212
 213 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 214 {
 215         int i;
 216         struct file_list *flist;
 217         char *dir = argv[0];
 218         extern int relative_paths;
 219         extern int recurse;
 220
 221         if (verbose > 2)
 222                 rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
 223
 224         if (!relative_paths && !push_dir(dir, 0)) {
 225                 rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
 226                 exit_cleanup(1);
 227         }
 228         argc--;
 229         argv++;
 230
 231         if (strcmp(dir,".")) {
 232                 int l = strlen(dir);
 233                 if (strcmp(dir,"/") == 0)
 234                         l = 0;
 235                 for (i=0;i<argc;i++)
 236                         argv[i] += l+1;
 237         }
 238
 239         if (argc == 0 && recurse) {
 240                 argc=1;
 241                 argv--;
 242                 argv[0] = ".";
 243         }
 244
 245         flist = send_file_list(f_out,argc,argv);
 246         if (!flist || flist->count == 0) {
 247                 exit_cleanup(0);
 248         }
 249
 250         send_files(flist,f_out,f_in);
 251         report(f_out);
 252         io_flush();
 253         exit_cleanup(0);
 254 }
 255
 256
 257 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 258 {
 259         int pid;
 260         int status=0;
 261         int recv_pipe[2];
 262         extern int preserve_hard_links;
 263
 264         if (preserve_hard_links)
 265                 init_hard_links(flist);
 266
 267         if (pipe(recv_pipe) < 0) {
 268                 rprintf(FERROR,"pipe failed in do_recv\n");
 269                 exit_cleanup(1);
 270         }
 271
 272         io_flush();
 273
 274         if ((pid=do_fork()) == 0) {
 275                 close(recv_pipe[0]);
 276                 if (f_in != f_out) close(f_out);
 277
 278                 recv_files(f_in,flist,local_name,recv_pipe[1]);
 279                 report(f_in);
 280
 281                 if (verbose > 3)
 282                         rprintf(FINFO,"do_recv waiting on %d\n",pid);
 283
 284                 io_flush();
 285                 _exit(0);
 286         }
 287
 288         close(recv_pipe[1]);
 289         io_close_input(f_in);
 290         if (f_in != f_out) close(f_in);
 291         generate_files(f_out,flist,local_name,recv_pipe[0]);
 292
 293         io_flush();
 294         waitpid(pid, &status, 0);
 295         return status;
 296 }
 297
 298
 299 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 300 {
 301         int status;
 302         struct file_list *flist;
 303         char *local_name=NULL;
 304         char *dir = NULL;
 305         extern int delete_mode;
 306         extern int am_daemon;
 307
 308         if (verbose > 2)
 309                 rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
 310
 311         if (argc > 0) {
 312                 dir = argv[0];
 313                 argc--;
 314                 argv++;
 315                 if (!am_daemon && !push_dir(dir, 0)) {
 316                         rprintf(FERROR,"push_dir %s : %s (4)\n",
 317                                 dir,strerror(errno));
 318                         exit_cleanup(1);
 319                 }
 320         }
 321
 322         if (delete_mode)
 323                 recv_exclude_list(f_in);
 324
 325         flist = recv_file_list(f_in);
 326         if (!flist || flist->count == 0) {
 327                 rprintf(FERROR,"server_recv: nothing to do\n");
 328                 exit_cleanup(1);
 329         }
 330
 331         if (argc > 0) {
 332                 if (strcmp(dir,".")) {
 333                         argv[0] += strlen(dir);
 334                         if (argv[0][0] == '/') argv[0]++;
 335                 }
 336                 local_name = get_local_name(flist,argv[0]);
 337         }
 338
 339         status = do_recv(f_in,f_out,flist,local_name);
 340         exit_cleanup(status);
 341 }
 342
 343
 344 void start_server(int f_in, int f_out, int argc, char *argv[])
 345 {
 346         extern int cvs_exclude;
 347         extern int am_sender;
 348
 349         setup_protocol(f_out, f_in);
 350
 351         if (am_sender) {
 352                 recv_exclude_list(f_in);
 353                 if (cvs_exclude)
 354                         add_cvs_excludes();
 355                 do_server_sender(f_in, f_out, argc, argv);
 356         } else {
 357                 do_server_recv(f_in, f_out, argc, argv);
 358         }
 359         exit_cleanup(0);
 360 }
 361
 362 int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 363 {
 364         struct file_list *flist;
 365         int status = 0, status2 = 0;
 366         char *local_name = NULL;
 367         extern int am_sender;
 368
 369         setup_protocol(f_out,f_in);
 370
 371         if (am_sender) {
 372                 extern int cvs_exclude;
 373                 extern int delete_mode;
 374                 if (cvs_exclude)
 375                         add_cvs_excludes();
 376                 if (delete_mode)
 377                         send_exclude_list(f_out);
 378                 flist = send_file_list(f_out,argc,argv);
 379                 if (verbose > 3)
 380                         rprintf(FINFO,"file list sent\n");
 381                 send_files(flist,f_out,f_in);
 382                 if (pid != -1) {
 383                         if (verbose > 3)
 384                                 rprintf(FINFO,"client_run waiting on %d\n",pid);
 385                         io_flush();
 386                         waitpid(pid, &status, 0);
 387                 }
 388                 report(-1);
 389                 exit_cleanup(status);
 390         }
 391
 392         send_exclude_list(f_out);
 393
 394         flist = recv_file_list(f_in);
 395         if (!flist || flist->count == 0) {
 396                 rprintf(FINFO,"client: nothing to do\n");
 397                 exit_cleanup(0);
 398         }
 399
 400         local_name = get_local_name(flist,argv[0]);
 401
 402         status2 = do_recv(f_in,f_out,flist,local_name);
 403
 404         if (pid != -1) {
 405                 if (verbose > 3)
 406                         rprintf(FINFO,"client_run2 waiting on %d\n",pid);
 407                 io_flush();
 408                 waitpid(pid, &status, 0);
 409         }
 410
 411         return status | status2;
 412 }
 413
 414
 415 int start_client(int argc, char *argv[])
 416 {
 417         char *p;
 418         char *shell_machine = NULL;
 419         char *shell_path = NULL;
 420         char *shell_user = NULL;
 421         int pid;
 422         int f_in,f_out;
 423         extern int local_server;
 424         extern int am_sender;
 425         extern char *shell_cmd;
 426
 427         p = strchr(argv[0],':');
 428
 429         if (p) {
 430                 if (p[1] == ':') {
 431                         *p = 0;
 432                         return start_socket_client(argv[0], p+2, argc-1, argv+1);
 433                 }
 434
 435                 if (argc < 2) {
 436                         usage(FERROR);
 437                         exit_cleanup(1);
 438                 }
 439
 440                 am_sender = 0;
 441                 *p = 0;
 442                 shell_machine = argv[0];
 443                 shell_path = p+1;
 444                 argc--;
 445                 argv++;
 446         } else {
 447                 am_sender = 1;
 448
 449                 p = strchr(argv[argc-1],':');
 450                 if (!p) {
 451                         local_server = 1;
 452                 } else if (p[1] == ':') {
 453                         *p = 0;
 454                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
 455                 }
 456
 457                 if (argc < 2) {
 458                         usage(FERROR);
 459                         exit_cleanup(1);
 460                 }
 461
 462                 if (local_server) {
 463                         shell_machine = NULL;
 464                         shell_path = argv[argc-1];
 465                 } else {
 466                         *p = 0;
 467                         shell_machine = argv[argc-1];
 468                         shell_path = p+1;
 469                 }
 470                 argc--;
 471         }
 472
 473         if (shell_machine) {
 474                 p = strchr(shell_machine,'@');
 475                 if (p) {
 476                         *p = 0;
 477                         shell_user = shell_machine;
 478                         shell_machine = p+1;
 479                 }
 480         }
 481
 482         if (verbose > 3) {
 483                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 484                         shell_cmd?shell_cmd:"",
 485                         shell_machine?shell_machine:"",
 486                         shell_user?shell_user:"",
 487                         shell_path?shell_path:"");
 488         }
 489
 490         if (!am_sender && argc != 1) {
 491                 usage(FERROR);
 492                 exit_cleanup(1);
 493         }
 494
 495         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 496
 497 #if HAVE_SETLINEBUF
 498         setlinebuf(stdout);
 499         setlinebuf(stderr);
 500 #endif
 501
 502         return client_run(f_in, f_out, pid, argc, argv);
 503 }
 504
 505
 506 RETSIGTYPE sigusr1_handler(int val) {
 507         exit_cleanup(1);
 508 }
 509
 510 int main(int argc,char *argv[])
 511 {
 512         extern int am_root;
 513         extern int orig_umask;
 514         extern int dry_run;
 515         extern int am_daemon;
 516         extern int am_server;
 517
 518         signal(SIGUSR1, sigusr1_handler);
 519
 520         starttime = time(NULL);
 521         am_root = (getuid() == 0);
 522
 523         memset(&stats, 0, sizeof(stats));
 524
 525         if (argc < 2) {
 526                 usage(FERROR);
 527                 exit_cleanup(1);
 528         }
 529
 530         /* we set a 0 umask so that correct file permissions can be
 531            carried across */
 532         orig_umask = (int)umask(0);
 533
 534         parse_arguments(argc, argv);
 535
 536         argc -= optind;
 537         argv += optind;
 538         optind = 0;
 539
 540         signal(SIGCHLD,SIG_IGN);
 541         signal(SIGINT,SIGNAL_CAST sig_int);
 542         signal(SIGPIPE,SIGNAL_CAST sig_int);
 543         signal(SIGHUP,SIGNAL_CAST sig_int);
 544
 545         if (am_daemon) {
 546                 return daemon_main();
 547         }
 548
 549         if (argc < 1) {
 550                 usage(FERROR);
 551                 exit_cleanup(1);
 552         }
 553
 554         if (dry_run)
 555                 verbose = MAX(verbose,1);
 556
 557 #ifndef SUPPORT_LINKS
 558         if (!am_server && preserve_links) {
 559                 rprintf(FERROR,"ERROR: symbolic links not supported\n");
 560                 exit_cleanup(1);
 561         }
 562 #endif
 563
 564         if (am_server) {
 565                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 566         }
 567
 568         return start_client(argc, argv);
 569 }
 570