main.c

   1 /* -*- c-file-style: "linux" -*-
   2
   3    Copyright (C) 1996-2001 by Andrew Tridgell <tridge@samba.org>
   4    Copyright (C) Paul Mackerras 1996
   5    Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "rsync.h"
  23
  24 time_t starttime = 0;
  25
  26 extern struct stats stats;
  27 extern int am_root;
  28 extern int am_server;
  29 extern int am_sender;
  30 extern int am_generator;
  31 extern int am_daemon;
  32 extern int verbose;
  33 extern int blocking_io;
  34 extern int cvs_exclude;
  35 extern int delete_mode;
  36 extern int delete_excluded;
  37 extern int delete_after;
  38 extern int daemon_over_rsh;
  39 extern int do_stats;
  40 extern int dry_run;
  41 extern int list_only;
  42 extern int local_server;
  43 extern int log_got_error;
  44 extern int module_id;
  45 extern int orig_umask;
  46 extern int keep_dirlinks;
  47 extern int preserve_hard_links;
  48 extern int protocol_version;
  49 extern int recurse;
  50 extern int relative_paths;
  51 extern int rsync_port;
  52 extern int whole_file;
  53 extern int read_batch;
  54 extern int write_batch;
  55 extern int filesfrom_fd;
  56 extern pid_t cleanup_child_pid;
  57 extern char *files_from;
  58 extern char *remote_filesfrom_file;
  59 extern char *rsync_path;
  60 extern char *shell_cmd;
  61 extern struct file_list *batch_flist;
  62
  63
  64 /* there's probably never more than at most 2 outstanding child processes,
  65  * but set it higher just in case.
  66  */
  67 #define MAXCHILDPROCS 5
  68
  69 struct pid_status {
  70         pid_t pid;
  71         int   status;
  72 } pid_stat_table[MAXCHILDPROCS];
  73
  74 static void show_malloc_stats(void);
  75
  76 /****************************************************************************
  77 wait for a process to exit, calling io_flush while waiting
  78 ****************************************************************************/
  79 void wait_process(pid_t pid, int *status)
  80 {
  81         pid_t waited_pid;
  82         int cnt;
  83
  84         while ((waited_pid = waitpid(pid, status, WNOHANG)) == 0) {
  85                 msleep(20);
  86                 io_flush(FULL_FLUSH);
  87         }
  88
  89         if (waited_pid == -1 && errno == ECHILD) {
  90                 /* status of requested child no longer available.
  91                  * check to see if it was processed by the sigchld_handler.
  92                  */
  93                 for (cnt = 0;  cnt < MAXCHILDPROCS; cnt++) {
  94                         if (pid == pid_stat_table[cnt].pid) {
  95                                 *status = pid_stat_table[cnt].status;
  96                                 pid_stat_table[cnt].pid = 0;
  97                                 break;
  98                         }
  99                 }
 100         }
 101
 102         /* TODO: If the child exited on a signal, then log an
 103          * appropriate error message.  Perhaps we should also accept a
 104          * message describing the purpose of the child.  Also indicate
 105          * this to the caller so that thhey know something went
 106          * wrong.  */
 107         *status = WEXITSTATUS(*status);
 108 }
 109
 110 static void report(int f)
 111 {
 112         time_t t = time(NULL);
 113
 114         if (do_stats && verbose > 1) {
 115                 /* These come out from every process */
 116                 show_malloc_stats();
 117                 show_flist_stats();
 118         }
 119
 120         if (am_generator)
 121                 return;
 122
 123         if (am_daemon) {
 124                 log_exit(0, __FILE__, __LINE__);
 125                 if (f == -1 || !am_sender)
 126                         return;
 127         }
 128
 129         if (am_server) {
 130                 if (am_sender) {
 131                         int64 w;
 132                         /* store total_written in a temporary
 133                          * because write_longint changes it */
 134                         w = stats.total_written;
 135                         write_longint(f,stats.total_read);
 136                         write_longint(f,w);
 137                         write_longint(f,stats.total_size);
 138                 }
 139                 return;
 140         }
 141
 142         /* this is the client */
 143
 144         if (!am_sender) {
 145                 int64 r;
 146                 stats.total_written = read_longint(f);
 147                 /* store total_read in a temporary, read_longint changes it */
 148                 r = read_longint(f);
 149                 stats.total_size = read_longint(f);
 150                 stats.total_read = r;
 151         }
 152
 153         if (do_stats) {
 154                 rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
 155                 rprintf(FINFO,"Number of files transferred: %d\n",
 156                         stats.num_transferred_files);
 157                 rprintf(FINFO,"Total file size: %.0f bytes\n",
 158                         (double)stats.total_size);
 159                 rprintf(FINFO,"Total transferred file size: %.0f bytes\n",
 160                         (double)stats.total_transferred_size);
 161                 rprintf(FINFO,"Literal data: %.0f bytes\n",
 162                         (double)stats.literal_data);
 163                 rprintf(FINFO,"Matched data: %.0f bytes\n",
 164                         (double)stats.matched_data);
 165                 rprintf(FINFO,"File list size: %d\n", stats.flist_size);
 166                 rprintf(FINFO,"Total bytes written: %.0f\n",
 167                         (double)stats.total_written);
 168                 rprintf(FINFO,"Total bytes read: %.0f\n",
 169                         (double)stats.total_read);
 170         }
 171
 172         if (verbose || do_stats) {
 173                 rprintf(FINFO,"\nwrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
 174                         (double)stats.total_written,
 175                         (double)stats.total_read,
 176                         (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
 177                 rprintf(FINFO,"total size is %.0f  speedup is %.2f\n",
 178                         (double)stats.total_size,
 179                         (1.0*stats.total_size)/(stats.total_written+stats.total_read));
 180         }
 181
 182         fflush(stdout);
 183         fflush(stderr);
 184 }
 185
 186
 187 /**
 188  * If our C library can get malloc statistics, then show them to FINFO
 189  **/
 190 static void show_malloc_stats(void)
 191 {
 192 #ifdef HAVE_MALLINFO
 193         struct mallinfo mi;
 194
 195         mi = mallinfo();
 196
 197         rprintf(FINFO, "\n" RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
 198                 getpid(),
 199                 am_server ? "server " : "",
 200                 am_daemon ? "daemon " : "",
 201                 who_am_i());
 202         rprintf(FINFO, "  arena:     %10d   (bytes from sbrk)\n", mi.arena);
 203         rprintf(FINFO, "  ordblks:   %10d   (chunks not in use)\n", mi.ordblks);
 204         rprintf(FINFO, "  smblks:    %10d\n", mi.smblks);
 205         rprintf(FINFO, "  hblks:     %10d   (chunks from mmap)\n", mi.hblks);
 206         rprintf(FINFO, "  hblkhd:    %10d   (bytes from mmap)\n", mi.hblkhd);
 207         rprintf(FINFO, "  allmem:    %10d   (bytes from sbrk + mmap)\n",
 208             mi.arena + mi.hblkhd);
 209         rprintf(FINFO, "  usmblks:   %10d\n", mi.usmblks);
 210         rprintf(FINFO, "  fsmblks:   %10d\n", mi.fsmblks);
 211         rprintf(FINFO, "  uordblks:  %10d   (bytes used)\n", mi.uordblks);
 212         rprintf(FINFO, "  fordblks:  %10d   (bytes free)\n", mi.fordblks);
 213         rprintf(FINFO, "  keepcost:  %10d   (bytes in releasable chunk)\n", mi.keepcost);
 214 #endif /* HAVE_MALLINFO */
 215 }
 216
 217
 218 /* Start the remote shell.   cmd may be NULL to use the default. */
 219 static pid_t do_cmd(char *cmd, char *machine, char *user, char *path,
 220                     int *f_in, int *f_out)
 221 {
 222         int i, argc = 0;
 223         char *args[MAX_ARGS];
 224         pid_t ret;
 225         char *tok, *dir = NULL;
 226         int dash_l_set = 0;
 227
 228         if (!read_batch && !local_server) {
 229                 char *rsh_env = getenv(RSYNC_RSH_ENV);
 230                 if (!cmd)
 231                         cmd = rsh_env;
 232                 if (!cmd)
 233                         cmd = RSYNC_RSH;
 234                 cmd = strdup(cmd);
 235                 if (!cmd)
 236                         goto oom;
 237
 238                 for (tok = strtok(cmd, " "); tok; tok = strtok(NULL, " ")) {
 239                         /* Comparison leaves rooms for server_options(). */
 240                         if (argc >= MAX_ARGS - 100) {
 241                                 rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
 242                                 exit_cleanup(RERR_SYNTAX);
 243                         }
 244                         args[argc++] = tok;
 245                 }
 246
 247                 /* check to see if we've already been given '-l user' in
 248                  * the remote-shell command */
 249                 for (i = 0; i < argc-1; i++) {
 250                         if (!strcmp(args[i], "-l") && args[i+1][0] != '-')
 251                                 dash_l_set = 1;
 252                 }
 253
 254 #if HAVE_REMSH
 255                 /* remsh (on HPUX) takes the arguments the other way around */
 256                 args[argc++] = machine;
 257                 if (user && !(daemon_over_rsh && dash_l_set)) {
 258                         args[argc++] = "-l";
 259                         args[argc++] = user;
 260                 }
 261 #else
 262                 if (user && !(daemon_over_rsh && dash_l_set)) {
 263                         args[argc++] = "-l";
 264                         args[argc++] = user;
 265                 }
 266                 args[argc++] = machine;
 267 #endif
 268
 269                 args[argc++] = rsync_path;
 270
 271                 if (blocking_io < 0) {
 272                         char *cp;
 273                         if ((cp = strrchr(cmd, '/')) != NULL)
 274                                 cp++;
 275                         else
 276                                 cp = cmd;
 277                         if (strcmp(cp, "rsh") == 0 || strcmp(cp, "remsh") == 0)
 278                                 blocking_io = 1;
 279                 }
 280
 281                 server_options(args,&argc);
 282
 283                 if (argc >= MAX_ARGS - 2) {
 284                         rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
 285                         exit_cleanup(RERR_SYNTAX);
 286                 }
 287         }
 288
 289         args[argc++] = ".";
 290
 291         if (!daemon_over_rsh && path && *path)
 292                 args[argc++] = path;
 293
 294         args[argc] = NULL;
 295
 296         if (verbose > 3) {
 297                 rprintf(FINFO,"cmd=");
 298                 for (i = 0; i < argc; i++)
 299                         rprintf(FINFO,"%s ",args[i]);
 300                 rprintf(FINFO,"\n");
 301         }
 302
 303         if (local_server) {
 304                 if (read_batch)
 305                         create_flist_from_batch(); /* sets batch_flist */
 306                 /* If the user didn't request --[no-]whole-file, force
 307                  * it on, but only if we're not batch processing. */
 308                 if (whole_file < 0 && !read_batch && !write_batch)
 309                         whole_file = 1;
 310                 ret = local_child(argc, args, f_in, f_out, child_main);
 311         } else {
 312                 ret = piped_child(args,f_in,f_out);
 313         }
 314
 315         if (dir)
 316                 free(dir);
 317
 318         return ret;
 319
 320 oom:
 321         out_of_memory("do_cmd");
 322         return 0; /* not reached */
 323 }
 324
 325
 326 static char *get_local_name(struct file_list *flist,char *name)
 327 {
 328         STRUCT_STAT st;
 329         int e;
 330
 331         if (verbose > 2)
 332                 rprintf(FINFO,"get_local_name count=%d %s\n",
 333                         flist->count, NS(name));
 334
 335         if (!name)
 336                 return NULL;
 337
 338         if (do_stat(name,&st) == 0) {
 339                 if (S_ISDIR(st.st_mode)) {
 340                         if (!push_dir(name)) {
 341                                 rsyserr(FERROR, errno, "push_dir#1 %s failed",
 342                                         full_fname(name));
 343                                 exit_cleanup(RERR_FILESELECT);
 344                         }
 345                         return NULL;
 346                 }
 347                 if (flist->count > 1) {
 348                         rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 349                         exit_cleanup(RERR_FILESELECT);
 350                 }
 351                 return name;
 352         }
 353
 354         if (flist->count <= 1 && ((e = strlen(name)) <= 1 || name[e-1] != '/'))
 355                 return name;
 356
 357         if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 358                 rsyserr(FERROR, errno, "mkdir %s failed", full_fname(name));
 359                 exit_cleanup(RERR_FILEIO);
 360         } else {
 361                 if (verbose > 0)
 362                         rprintf(FINFO,"created directory %s\n",name);
 363         }
 364
 365         if (!push_dir(name)) {
 366                 rsyserr(FERROR, errno, "push_dir#2 %s failed",
 367                         full_fname(name));
 368                 exit_cleanup(RERR_FILESELECT);
 369         }
 370
 371         return NULL;
 372 }
 373
 374
 375 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 376 {
 377         int i;
 378         struct file_list *flist;
 379         char *dir = argv[0];
 380
 381         if (verbose > 2) {
 382                 rprintf(FINFO, "server_sender starting pid=%ld\n",
 383                         (long)getpid());
 384         }
 385
 386         if (am_daemon && lp_write_only(module_id) && am_sender) {
 387                 rprintf(FERROR, "ERROR: module is write only\n");
 388                 exit_cleanup(RERR_SYNTAX);
 389                 return;
 390         }
 391
 392         if (!relative_paths && !push_dir(dir)) {
 393                 rsyserr(FERROR, errno, "push_dir#3 %s failed",
 394                         full_fname(dir));
 395                 exit_cleanup(RERR_FILESELECT);
 396         }
 397         argc--;
 398         argv++;
 399
 400         if (strcmp(dir,".")) {
 401                 int l = strlen(dir);
 402                 if (strcmp(dir,"/") == 0)
 403                         l = 0;
 404                 for (i = 0; i < argc; i++)
 405                         argv[i] += l+1;
 406         }
 407
 408         if (argc == 0 && recurse) {
 409                 argc = 1;
 410                 argv--;
 411                 argv[0] = ".";
 412         }
 413
 414         flist = send_file_list(f_out,argc,argv);
 415         if (!flist || flist->count == 0) {
 416                 exit_cleanup(0);
 417         }
 418
 419         io_start_buffering_in(f_in);
 420         io_start_buffering_out(f_out);
 421         send_files(flist,f_out,f_in);
 422         io_flush(FULL_FLUSH);
 423         report(f_out);
 424         if (protocol_version >= 24) {
 425                 /* final goodbye message */
 426                 read_int(f_in);
 427         }
 428         io_flush(FULL_FLUSH);
 429         exit_cleanup(0);
 430 }
 431
 432
 433 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 434 {
 435         int pid;
 436         int status = 0;
 437         int error_pipe[2];
 438
 439         if (preserve_hard_links)
 440                 init_hard_links(flist);
 441
 442         if (!delete_after) {
 443                 /* I moved this here from recv_files() to prevent a race condition */
 444                 if (recurse && delete_mode && !local_name && flist->count>0) {
 445                         delete_files(flist);
 446                 }
 447         }
 448
 449         if (fd_pair(error_pipe) < 0) {
 450                 rprintf(FERROR,"error pipe failed in do_recv\n");
 451                 exit_cleanup(RERR_SOCKETIO);
 452         }
 453
 454         io_flush(NORMAL_FLUSH);
 455
 456         if ((pid = do_fork()) == 0) {
 457                 close(error_pipe[0]);
 458                 if (f_in != f_out)
 459                         close(f_out);
 460
 461                 /* we can't let two processes write to the socket at one time */
 462                 io_multiplexing_close();
 463
 464                 /* set place to send errors */
 465                 set_msg_fd_out(error_pipe[1]);
 466
 467                 recv_files(f_in,flist,local_name);
 468                 io_flush(FULL_FLUSH);
 469                 report(f_in);
 470
 471                 send_msg(MSG_DONE, "", 0);
 472                 io_flush(FULL_FLUSH);
 473                 /* finally we go to sleep until our parent kills us
 474                  * with a USR2 signal. We sleep for a short time as on
 475                  * some OSes a signal won't interrupt a sleep! */
 476                 while (1)
 477                         msleep(20);
 478         }
 479
 480         am_generator = 1;
 481
 482         close(error_pipe[1]);
 483         if (f_in != f_out)
 484                 close(f_in);
 485
 486         io_start_buffering_out(f_out);
 487
 488         set_msg_fd_in(error_pipe[0]);
 489
 490         generate_files(f_out, flist, local_name);
 491
 492         get_redo_num(); /* Read final MSG_DONE and any prior messages. */
 493         report(-1);
 494         io_flush(FULL_FLUSH);
 495         if (protocol_version >= 24) {
 496                 /* send a final goodbye message */
 497                 write_int(f_out, -1);
 498         }
 499         io_flush(FULL_FLUSH);
 500
 501         set_msg_fd_in(-1);
 502         kill(pid, SIGUSR2);
 503         wait_process(pid, &status);
 504         return status;
 505 }
 506
 507
 508 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 509 {
 510         int status;
 511         struct file_list *flist;
 512         char *local_name = NULL;
 513         char *dir = NULL;
 514
 515         if (verbose > 2) {
 516                 rprintf(FINFO, "server_recv(%d) starting pid=%ld\n",
 517                         argc, (long)getpid());
 518         }
 519
 520         if (am_daemon && lp_read_only(module_id) && !am_sender) {
 521                 rprintf(FERROR,"ERROR: module is read only\n");
 522                 exit_cleanup(RERR_SYNTAX);
 523                 return;
 524         }
 525
 526
 527         if (argc > 0) {
 528                 dir = argv[0];
 529                 argc--;
 530                 argv++;
 531                 if (!am_daemon && !push_dir(dir)) {
 532                         rsyserr(FERROR, errno, "push_dir#4 %s failed",
 533                                 full_fname(dir));
 534                         exit_cleanup(RERR_FILESELECT);
 535                 }
 536         }
 537
 538         io_start_buffering_in(f_in);
 539         if (delete_mode && !delete_excluded)
 540                 recv_exclude_list(f_in);
 541
 542         if (filesfrom_fd >= 0) {
 543                 /* We're receiving the file info from the sender, so we need
 544                  * the IO routines to automatically write out the names onto
 545                  * our f_out socket as we read the list info from the sender.
 546                  * This avoids both deadlock and extra delays/buffers. */
 547                 io_set_filesfrom_fds(filesfrom_fd, f_out);
 548                 filesfrom_fd = -1;
 549         }
 550
 551         if (read_batch)
 552                 flist = batch_flist;
 553         else
 554                 flist = recv_file_list(f_in);
 555         if (!flist) {
 556                 rprintf(FERROR,"server_recv: recv_file_list error\n");
 557                 exit_cleanup(RERR_FILESELECT);
 558         }
 559
 560         if (argc > 0) {
 561                 if (strcmp(dir,".")) {
 562                         argv[0] += strlen(dir);
 563                         if (argv[0][0] == '/')
 564                                 argv[0]++;
 565                 }
 566                 local_name = get_local_name(flist,argv[0]);
 567         }
 568
 569         status = do_recv(f_in,f_out,flist,local_name);
 570         exit_cleanup(status);
 571 }
 572
 573
 574 int child_main(int argc, char *argv[])
 575 {
 576         start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 577         return 0;
 578 }
 579
 580
 581 void start_server(int f_in, int f_out, int argc, char *argv[])
 582 {
 583         setup_protocol(f_out, f_in);
 584
 585         set_nonblocking(f_in);
 586         set_nonblocking(f_out);
 587
 588         if (protocol_version >= 23)
 589                 io_start_multiplex_out(f_out);
 590
 591         if (am_sender) {
 592                 keep_dirlinks = 0; /* Must be disabled on the sender. */
 593                 if (!read_batch) {
 594                         recv_exclude_list(f_in);
 595                         if (cvs_exclude)
 596                                 add_cvs_excludes();
 597                 }
 598                 do_server_sender(f_in, f_out, argc, argv);
 599         } else {
 600                 do_server_recv(f_in, f_out, argc, argv);
 601         }
 602         exit_cleanup(0);
 603 }
 604
 605
 606 /*
 607  * This is called once the connection has been negotiated.  It is used
 608  * for rsyncd, remote-shell, and local connections.
 609  */
 610 int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
 611 {
 612         struct file_list *flist = NULL;
 613         int status = 0, status2 = 0;
 614         char *local_name = NULL;
 615
 616         cleanup_child_pid = pid;
 617         if (read_batch)
 618                 flist = batch_flist;
 619
 620         set_nonblocking(f_in);
 621         set_nonblocking(f_out);
 622
 623         setup_protocol(f_out,f_in);
 624
 625         if (protocol_version >= 23)
 626                 io_start_multiplex_in(f_in);
 627
 628         if (am_sender) {
 629                 keep_dirlinks = 0; /* Must be disabled on the sender. */
 630                 io_start_buffering_out(f_out);
 631                 if (cvs_exclude)
 632                         add_cvs_excludes();
 633                 if (delete_mode && !delete_excluded)
 634                         send_exclude_list(f_out);
 635                 if (remote_filesfrom_file)
 636                         filesfrom_fd = f_in;
 637                 if (!read_batch) /* don't write to pipe */
 638                         flist = send_file_list(f_out,argc,argv);
 639                 if (verbose > 3)
 640                         rprintf(FINFO,"file list sent\n");
 641
 642                 io_flush(NORMAL_FLUSH);
 643                 send_files(flist,f_out,f_in);
 644                 io_flush(FULL_FLUSH);
 645                 if (protocol_version >= 24) {
 646                         /* final goodbye message */
 647                         read_int(f_in);
 648                 }
 649                 if (pid != -1) {
 650                         if (verbose > 3)
 651                                 rprintf(FINFO,"client_run waiting on %d\n", (int) pid);
 652                         io_flush(FULL_FLUSH);
 653                         wait_process(pid, &status);
 654                 }
 655                 report(-1);
 656                 io_flush(FULL_FLUSH);
 657                 exit_cleanup(status);
 658         }
 659
 660         if (argc == 0)
 661                 list_only = 1;
 662
 663         if (!read_batch)
 664                 send_exclude_list(f_out);
 665
 666         if (filesfrom_fd >= 0) {
 667                 io_set_filesfrom_fds(filesfrom_fd, f_out);
 668                 filesfrom_fd = -1;
 669         }
 670
 671         flist = recv_file_list(f_in);
 672         if (!flist || flist->count == 0) {
 673                 rprintf(FINFO, "client: nothing to do: "
 674                         "perhaps you need to specify some filenames or "
 675                         "the --recursive option?\n");
 676                 exit_cleanup(0);
 677         }
 678
 679         local_name = get_local_name(flist,argv[0]);
 680
 681         status2 = do_recv(f_in,f_out,flist,local_name);
 682
 683         if (pid != -1) {
 684                 if (verbose > 3)
 685                         rprintf(FINFO,"client_run2 waiting on %d\n", (int) pid);
 686                 io_flush(FULL_FLUSH);
 687                 wait_process(pid, &status);
 688         }
 689
 690         return MAX(status, status2);
 691 }
 692
 693 static int copy_argv (char *argv[])
 694 {
 695         int i;
 696
 697         for (i = 0; argv[i]; i++) {
 698                 if (!(argv[i] = strdup(argv[i]))) {
 699                         rprintf (FERROR, "out of memory at %s(%d)\n",
 700                                  __FILE__, __LINE__);
 701                         return RERR_MALLOC;
 702                 }
 703         }
 704
 705         return 0;
 706 }
 707
 708
 709 /**
 710  * Start a client for either type of remote connection.  Work out
 711  * whether the arguments request a remote shell or rsyncd connection,
 712  * and call the appropriate connection function, then run_client.
 713  *
 714  * Calls either start_socket_client (for sockets) or do_cmd and
 715  * client_run (for ssh).
 716  **/
 717 static int start_client(int argc, char *argv[])
 718 {
 719         char *p;
 720         char *shell_machine = NULL;
 721         char *shell_path = NULL;
 722         char *shell_user = NULL;
 723         int ret;
 724         pid_t pid;
 725         int f_in,f_out;
 726         int rc;
 727
 728         /* Don't clobber argv[] so that ps(1) can still show the right
 729          * command line. */
 730         if ((rc = copy_argv(argv)))
 731                 return rc;
 732
 733         /* rsync:// always uses rsync server over direct socket connection */
 734         if (strncasecmp(URL_PREFIX, argv[0], strlen(URL_PREFIX)) == 0) {
 735                 char *host, *path;
 736
 737                 host = argv[0] + strlen(URL_PREFIX);
 738                 p = strchr(host,'/');
 739                 if (p) {
 740                         *p = 0;
 741                         path = p+1;
 742                 } else {
 743                         path = "";
 744                 }
 745                 p = strchr(host,':');
 746                 if (p) {
 747                         rsync_port = atoi(p+1);
 748                         *p = 0;
 749                 }
 750                 return start_socket_client(host, path, argc-1, argv+1);
 751         }
 752
 753         if (!read_batch) { /* for read_batch, NO source is specified */
 754                 p = find_colon(argv[0]);
 755                 if (p) { /* source is remote */
 756                         if (remote_filesfrom_file
 757                          && remote_filesfrom_file != files_from + 1
 758                          && strncmp(files_from, argv[0], p-argv[0]+1) != 0) {
 759                                 rprintf(FERROR,
 760                                         "--files-from hostname is not transfer hostname\n");
 761                                 exit_cleanup(RERR_SYNTAX);
 762                         }
 763                         if (p[1] == ':') { /* double colon */
 764                                 *p = 0;
 765                                 if (!shell_cmd) {
 766                                         return start_socket_client(argv[0], p+2,
 767                                                                    argc-1, argv+1);
 768                                 }
 769                                 p++;
 770                                 daemon_over_rsh = 1;
 771                         }
 772
 773                         if (argc < 1) { /* destination required */
 774                                 usage(FERROR);
 775                                 exit_cleanup(RERR_SYNTAX);
 776                         }
 777
 778                         am_sender = 0;
 779                         *p = 0;
 780                         shell_machine = argv[0];
 781                         shell_path = p+1;
 782                         argv++;
 783                 } else { /* source is local */
 784                         am_sender = 1;
 785
 786                         /* rsync:// destination uses rsync server over direct socket */
 787                         if (strncasecmp(URL_PREFIX, argv[argc-1], strlen(URL_PREFIX)) == 0) {
 788                                 char *host, *path;
 789
 790                                 host = argv[argc-1] + strlen(URL_PREFIX);
 791                                 p = strchr(host,'/');
 792                                 if (p) {
 793                                         *p = 0;
 794                                         path = p+1;
 795                                 } else {
 796                                         path = "";
 797                                 }
 798                                 p = strchr(host,':');
 799                                 if (p) {
 800                                         rsync_port = atoi(p+1);
 801                                         *p = 0;
 802                                 }
 803                                 return start_socket_client(host, path, argc-1, argv);
 804                         }
 805
 806                         p = find_colon(argv[argc-1]); /* look in dest arg */
 807                         if (p && remote_filesfrom_file
 808                          && remote_filesfrom_file != files_from + 1
 809                          && strncmp(files_from, argv[argc-1], p-argv[argc-1]+1) != 0) {
 810                                 rprintf(FERROR,
 811                                         "--files-from hostname is not transfer hostname\n");
 812                                 exit_cleanup(RERR_SYNTAX);
 813                         }
 814                         if (!p) { /* no colon found, so src & dest are local */
 815                                 local_server = 1;
 816                                 if (remote_filesfrom_file) {
 817                                         rprintf(FERROR,
 818                                                 "--files-from is remote but transfer is local\n");
 819                                         exit_cleanup(RERR_SYNTAX);
 820                                 }
 821                         } else if (p[1] == ':') { /* double colon */
 822                                 *p = 0;
 823                                 if (!shell_cmd) {
 824                                         return start_socket_client(argv[argc-1], p+2,
 825                                                                    argc-1, argv);
 826                                 }
 827                                 p++;
 828                                 daemon_over_rsh = 1;
 829                         }
 830
 831                         if (argc < 2) {
 832                                 usage(FERROR);
 833                                 exit_cleanup(RERR_SYNTAX);
 834                         }
 835
 836                         if (local_server) {
 837                                 shell_machine = NULL;
 838                                 shell_path = argv[argc-1];
 839                         } else {
 840                                 *p = 0;
 841                                 shell_machine = argv[argc-1];
 842                                 shell_path = p+1;
 843                         }
 844                 }
 845                 argc--;
 846         } else {  /* read_batch */
 847                 am_sender = 1;
 848                 local_server = 1;
 849                 shell_path = argv[argc-1];
 850         }
 851
 852         if (shell_machine) {
 853                 p = strrchr(shell_machine,'@');
 854                 if (p) {
 855                         *p = 0;
 856                         shell_user = shell_machine;
 857                         shell_machine = p+1;
 858                 }
 859         }
 860
 861         if (verbose > 3) {
 862                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 863                         shell_cmd?shell_cmd:"",
 864                         shell_machine?shell_machine:"",
 865                         shell_user?shell_user:"",
 866                         shell_path?shell_path:"");
 867         }
 868
 869         /* for remote source, only single dest arg can remain ... */
 870         if (!am_sender && argc > 1) {
 871                 usage(FERROR);
 872                 exit_cleanup(RERR_SYNTAX);
 873         }
 874
 875         /* ... or no dest at all */
 876         if (!am_sender && argc == 0) {
 877                 list_only = 1;
 878         }
 879
 880         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,
 881                      &f_in,&f_out);
 882
 883         /* if we're running an rsync server on the remote host over a
 884          * remote shell command, we need to do the RSYNCD protocol first */
 885         if (daemon_over_rsh) {
 886                 int tmpret;
 887                 tmpret = start_inband_exchange(shell_user, shell_path,
 888                                                f_in, f_out, argc);
 889                 if (tmpret < 0)
 890                         return tmpret;
 891         }
 892
 893         ret = client_run(f_in, f_out, pid, argc, argv);
 894
 895         fflush(stdout);
 896         fflush(stderr);
 897
 898         return ret;
 899 }
 900
 901
 902 static RETSIGTYPE sigusr1_handler(UNUSED(int val))
 903 {
 904         exit_cleanup(RERR_SIGNAL);
 905 }
 906
 907 static RETSIGTYPE sigusr2_handler(UNUSED(int val))
 908 {
 909         if (log_got_error) _exit(RERR_PARTIAL);
 910         _exit(0);
 911 }
 912
 913 static RETSIGTYPE sigchld_handler(UNUSED(int val))
 914 {
 915 #ifdef WNOHANG
 916         int cnt, status;
 917         pid_t pid;
 918         /* An empty waitpid() loop was put here by Tridge and we could never
 919          * get him to explain why he put it in, so rather than taking it
 920          * out we're instead saving the child exit statuses for later use.
 921          * The waitpid() loop presumably eliminates all possibility of leaving
 922          * zombie children, maybe that's why he did it.
 923          */
 924         while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
 925                 /* save the child's exit status */
 926                 for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) {
 927                         if (pid_stat_table[cnt].pid == 0) {
 928                                 pid_stat_table[cnt].pid = pid;
 929                                 pid_stat_table[cnt].status = status;
 930                                 break;
 931                         }
 932                 }
 933         }
 934 #endif
 935 }
 936
 937
 938 /**
 939  * This routine catches signals and tries to send them to gdb.
 940  *
 941  * Because it's called from inside a signal handler it ought not to
 942  * use too many library routines.
 943  *
 944  * @todo Perhaps use "screen -X" instead/as well, to help people
 945  * debugging without easy access to X.  Perhaps use an environment
 946  * variable, or just call a script?
 947  *
 948  * @todo The /proc/ magic probably only works on Linux (and
 949  * Solaris?)  Can we be more portable?
 950  **/
 951 #ifdef MAINTAINER_MODE
 952 const char *get_panic_action(void)
 953 {
 954         const char *cmd_fmt = getenv("RSYNC_PANIC_ACTION");
 955
 956         if (cmd_fmt)
 957                 return cmd_fmt;
 958         else
 959                 return "xterm -display :0 -T Panic -n Panic "
 960                         "-e gdb /proc/%d/exe %d";
 961 }
 962
 963
 964 /**
 965  * Handle a fatal signal by launching a debugger, controlled by $RSYNC_PANIC_ACTION.
 966  *
 967  * This signal handler is only installed if we were configured with
 968  * --enable-maintainer-mode.  Perhaps it should always be on and we
 969  * should just look at the environment variable, but I'm a bit leery
 970  * of a signal sending us into a busy loop.
 971  **/
 972 static RETSIGTYPE rsync_panic_handler(UNUSED(int whatsig))
 973 {
 974         char cmd_buf[300];
 975         int ret;
 976
 977         sprintf(cmd_buf, get_panic_action(),
 978                 getpid(), getpid());
 979
 980         /* Unless we failed to execute gdb, we allow the process to
 981          * continue.  I'm not sure if that's right. */
 982         ret = system(cmd_buf);
 983         if (ret)
 984                 _exit(ret);
 985 }
 986 #endif
 987
 988
 989 int main(int argc,char *argv[])
 990 {
 991         int ret;
 992         int orig_argc;
 993         char **orig_argv;
 994
 995         orig_argc = argc;
 996         orig_argv = argv;
 997
 998         signal(SIGUSR1, sigusr1_handler);
 999         signal(SIGUSR2, sigusr2_handler);
1000         signal(SIGCHLD, sigchld_handler);
1001 #ifdef MAINTAINER_MODE
1002         signal(SIGSEGV, rsync_panic_handler);
1003         signal(SIGFPE, rsync_panic_handler);
1004         signal(SIGABRT, rsync_panic_handler);
1005         signal(SIGBUS, rsync_panic_handler);
1006 #endif /* def MAINTAINER_MODE */
1007
1008         starttime = time(NULL);
1009         am_root = (MY_UID() == 0);
1010
1011         memset(&stats, 0, sizeof(stats));
1012
1013         if (argc < 2) {
1014                 usage(FERROR);
1015                 exit_cleanup(RERR_SYNTAX);
1016         }
1017
1018         /* we set a 0 umask so that correct file permissions can be
1019          * carried across */
1020         orig_umask = (int)umask(0);
1021
1022         if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
1023                 /* FIXME: We ought to call the same error-handling
1024                  * code here, rather than relying on getopt. */
1025                 option_error();
1026                 exit_cleanup(RERR_SYNTAX);
1027         }
1028
1029         signal(SIGINT,SIGNAL_CAST sig_int);
1030         signal(SIGHUP,SIGNAL_CAST sig_int);
1031         signal(SIGTERM,SIGNAL_CAST sig_int);
1032
1033         /* Ignore SIGPIPE; we consistently check error codes and will
1034          * see the EPIPE. */
1035         signal(SIGPIPE, SIG_IGN);
1036
1037         /* Initialize push_dir here because on some old systems getcwd
1038          * (implemented by forking "pwd" and reading its output) doesn't
1039          * work when there are other child processes.  Also, on all systems
1040          * that implement getcwd that way "pwd" can't be found after chroot. */
1041         push_dir(NULL);
1042
1043         init_flist();
1044
1045         if (write_batch && !am_server) {
1046                 write_batch_argvs_file(orig_argc, orig_argv);
1047         }
1048
1049         if (am_daemon && !am_server)
1050                 return daemon_main();
1051
1052         if (argc < 1) {
1053                 usage(FERROR);
1054                 exit_cleanup(RERR_SYNTAX);
1055         }
1056
1057         if (dry_run)
1058                 verbose = MAX(verbose,1);
1059
1060         if (am_server) {
1061                 set_nonblocking(STDIN_FILENO);
1062                 set_nonblocking(STDOUT_FILENO);
1063                 if (am_daemon)
1064                         return start_daemon(STDIN_FILENO, STDOUT_FILENO);
1065                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
1066         }
1067
1068         ret = start_client(argc, argv);
1069         if (ret == -1)
1070                 exit_cleanup(RERR_STARTCLIENT);
1071         else
1072                 exit_cleanup(ret);
1073
1074         return ret;
1075 }