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 struct stats stats;
  27
  28 extern int verbose;
  29
  30 static void show_malloc_stats(void);
  31
  32 /****************************************************************************
  33 wait for a process to exit, calling io_flush while waiting
  34 ****************************************************************************/
  35 void wait_process(pid_t pid, int *status)
  36 {
  37         while (waitpid(pid, status, WNOHANG) == 0) {
  38                 msleep(20);
  39                 io_flush();
  40         }
  41
  42         /* TODO: If the child exited on a signal, then log an
  43          * appropriate error message.  Perhaps we should also accept a
  44          * message describing the purpose of the child.  Also indicate
  45          * this to the caller so that thhey know something went
  46          * wrong.  */
  47         *status = WEXITSTATUS(*status);
  48 }
  49
  50 static void report(int f)
  51 {
  52         time_t t = time(NULL);
  53         extern int am_server;
  54         extern int am_sender;
  55         extern int am_daemon;
  56         extern int do_stats;
  57         extern int remote_version;
  58         int send_stats;
  59
  60         if (do_stats) {
  61                 /* These come out from every process */
  62                 show_malloc_stats();
  63                 show_flist_stats();
  64         }
  65
  66         if (am_daemon) {
  67                 log_exit(0, __FILE__, __LINE__);
  68                 if (f == -1 || !am_sender) return;
  69         }
  70
  71         send_stats = verbose || (remote_version >= 20);
  72         if (am_server) {
  73                 if (am_sender && send_stats) {
  74                         int64 w;
  75                         /* store total_written in a temporary
  76                             because write_longint changes it */
  77                         w = stats.total_written;
  78                         write_longint(f,stats.total_read);
  79                         write_longint(f,w);
  80                         write_longint(f,stats.total_size);
  81                 }
  82                 return;
  83         }
  84
  85         /* this is the client */
  86
  87         if (!am_sender && send_stats) {
  88                 int64 r;
  89                 stats.total_written = read_longint(f);
  90                 /* store total_read in a temporary, read_longint changes it */
  91                 r = read_longint(f);
  92                 stats.total_size = read_longint(f);
  93                 stats.total_read = r;
  94         }
  95
  96         if (do_stats) {
  97                 if (!am_sender && !send_stats) {
  98                     /* missing the bytes written by the generator */
  99                     rprintf(FINFO, "\nCannot show stats as receiver because remote protocol version is less than 20\n");
 100                     rprintf(FINFO, "Use --stats -v to show stats\n");
 101                     return;
 102                 }
 103                 rprintf(FINFO,"\nNumber of files: %d\n", stats.num_files);
 104                 rprintf(FINFO,"Number of files transferred: %d\n",
 105                        stats.num_transferred_files);
 106                 rprintf(FINFO,"Total file size: %.0f bytes\n",
 107                        (double)stats.total_size);
 108                 rprintf(FINFO,"Total transferred file size: %.0f bytes\n",
 109                        (double)stats.total_transferred_size);
 110                 rprintf(FINFO,"Literal data: %.0f bytes\n",
 111                        (double)stats.literal_data);
 112                 rprintf(FINFO,"Matched data: %.0f bytes\n",
 113                        (double)stats.matched_data);
 114                 rprintf(FINFO,"File list size: %d\n", stats.flist_size);
 115                 rprintf(FINFO,"Total bytes written: %.0f\n",
 116                        (double)stats.total_written);
 117                 rprintf(FINFO,"Total bytes read: %.0f\n\n",
 118                        (double)stats.total_read);
 119         }
 120
 121         if (verbose || do_stats) {
 122                 rprintf(FINFO,"wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
 123                        (double)stats.total_written,
 124                        (double)stats.total_read,
 125                        (stats.total_written+stats.total_read)/(0.5 + (t-starttime)));
 126                 rprintf(FINFO,"total size is %.0f  speedup is %.2f\n",
 127                        (double)stats.total_size,
 128                        (1.0*stats.total_size)/(stats.total_written+stats.total_read));
 129         }
 130
 131         fflush(stdout);
 132         fflush(stderr);
 133 }
 134
 135
 136 /**
 137  * If our C library can get malloc statistics, then show them to FINFO
 138  **/
 139 static void show_malloc_stats(void)
 140 {
 141 #ifdef HAVE_MALLINFO
 142         struct mallinfo mi;
 143         extern int am_server;
 144         extern int am_sender;
 145         extern int am_daemon;
 146
 147         mi = mallinfo();
 148
 149         rprintf(FINFO, RSYNC_NAME "[%d] (%s%s%s) heap statistics:\n",
 150                 getpid(),
 151                 am_server ? "server " : "",
 152                 am_daemon ? "daemon " : "",
 153                 am_sender ? "sender" : "receiver");
 154         rprintf(FINFO, "  arena:     %10d   (bytes from sbrk)\n", mi.arena);
 155         rprintf(FINFO, "  ordblks:   %10d   (chunks not in use)\n", mi.ordblks);
 156         rprintf(FINFO, "  smblks:    %10d\n", mi.smblks);
 157         rprintf(FINFO, "  hblks:     %10d   (chunks from mmap)\n", mi.hblks);
 158         rprintf(FINFO, "  hblkhd:    %10d   (bytes from mmap)\n", mi.hblkhd);
 159         rprintf(FINFO, "  usmblks:   %10d\n", mi.usmblks);
 160         rprintf(FINFO, "  fsmblks:   %10d\n", mi.fsmblks);
 161         rprintf(FINFO, "  uordblks:  %10d   (bytes used)\n", mi.uordblks);
 162         rprintf(FINFO, "  fordblks:  %10d   (bytes free)\n", mi.fordblks);
 163         rprintf(FINFO, "  keepcost:  %10d   (bytes in releasable chunk)\n", mi.keepcost);
 164 #endif /* HAVE_MALLINFO */
 165 }
 166
 167
 168 /* Start the remote shell.   cmd may be NULL to use the default. */
 169 static pid_t do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
 170 {
 171         char *args[100];
 172         int i,argc=0;
 173         pid_t ret;
 174         char *tok,*dir=NULL;
 175         extern int local_server;
 176         extern char *rsync_path;
 177         extern int blocking_io;
 178         extern int read_batch;
 179
 180         if (!read_batch && !local_server) {
 181                 if (!cmd)
 182                         cmd = getenv(RSYNC_RSH_ENV);
 183                 if (!cmd)
 184                         cmd = RSYNC_RSH;
 185                 cmd = strdup(cmd);
 186                 if (!cmd)
 187                         goto oom;
 188
 189                 for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
 190                         args[argc++] = tok;
 191                 }
 192
 193 #if HAVE_REMSH
 194                 /* remsh (on HPUX) takes the arguments the other way around */
 195                 args[argc++] = machine;
 196                 if (user) {
 197                         args[argc++] = "-l";
 198                         args[argc++] = user;
 199                 }
 200 #else
 201                 if (user) {
 202                         args[argc++] = "-l";
 203                         args[argc++] = user;
 204                 }
 205                 args[argc++] = machine;
 206 #endif
 207
 208                 args[argc++] = rsync_path;
 209
 210                 if ((blocking_io == -1) && (strcmp(cmd, RSYNC_RSH) == 0))
 211                         blocking_io = 1;
 212
 213                 server_options(args,&argc);
 214
 215         }
 216
 217         args[argc++] = ".";
 218
 219         if (path && *path)
 220                 args[argc++] = path;
 221
 222         args[argc] = NULL;
 223
 224         if (verbose > 3) {
 225                 rprintf(FINFO,"cmd=");
 226                 for (i=0;i<argc;i++)
 227                         rprintf(FINFO,"%s ",args[i]);
 228                 rprintf(FINFO,"\n");
 229         }
 230
 231         if (local_server) {
 232                 if (read_batch)
 233                     create_flist_from_batch(); /* sets batch_flist */
 234                 ret = local_child(argc, args, f_in, f_out);
 235         } else {
 236                 ret = piped_child(args,f_in,f_out);
 237         }
 238
 239         if (dir) free(dir);
 240
 241         return ret;
 242
 243 oom:
 244         out_of_memory("do_cmd");
 245         return 0; /* not reached */
 246 }
 247
 248
 249
 250
 251 static char *get_local_name(struct file_list *flist,char *name)
 252 {
 253         STRUCT_STAT st;
 254         extern int orig_umask;
 255
 256         if (verbose > 2)
 257                 rprintf(FINFO,"get_local_name count=%d %s\n",
 258                         flist->count, NS(name));
 259
 260         if (!name)
 261                 return NULL;
 262
 263         if (do_stat(name,&st) == 0) {
 264                 if (S_ISDIR(st.st_mode)) {
 265                         if (!push_dir(name, 0)) {
 266                                 rprintf(FERROR,"push_dir %s : %s (1)\n",
 267                                         name,strerror(errno));
 268                                 exit_cleanup(RERR_FILESELECT);
 269                         }
 270                         return NULL;
 271                 }
 272                 if (flist->count > 1) {
 273                         rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 274                         exit_cleanup(RERR_FILESELECT);
 275                 }
 276                 return name;
 277         }
 278
 279         if (flist->count <= 1)
 280                 return name;
 281
 282         if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 283                 rprintf(FERROR, RSYNC_NAME ": mkdir %s: %s\n",
 284                         name, strerror(errno));
 285                 exit_cleanup(RERR_FILEIO);
 286         } else {
 287                 if (verbose > 0)
 288                         rprintf(FINFO,"created directory %s\n",name);
 289         }
 290
 291         if (!push_dir(name, 0)) {
 292                 rprintf(FERROR, RSYNC_NAME ": push_dir %s: %s\n",
 293                         name, strerror(errno));
 294                 exit_cleanup(RERR_FILESELECT);
 295         }
 296
 297         return NULL;
 298 }
 299
 300
 301
 302
 303 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 304 {
 305         int i;
 306         struct file_list *flist;
 307         char *dir = argv[0];
 308         extern int relative_paths;
 309         extern int recurse;
 310         extern int remote_version;
 311
 312         if (verbose > 2)
 313                 rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
 314
 315         if (!relative_paths && !push_dir(dir, 0)) {
 316                 rprintf(FERROR,"push_dir %s: %s (3)\n",dir,strerror(errno));
 317                 exit_cleanup(RERR_FILESELECT);
 318         }
 319         argc--;
 320         argv++;
 321
 322         if (strcmp(dir,".")) {
 323                 int l = strlen(dir);
 324                 if (strcmp(dir,"/") == 0)
 325                         l = 0;
 326                 for (i=0;i<argc;i++)
 327                         argv[i] += l+1;
 328         }
 329
 330         if (argc == 0 && recurse) {
 331                 argc=1;
 332                 argv--;
 333                 argv[0] = ".";
 334         }
 335
 336         flist = send_file_list(f_out,argc,argv);
 337         if (!flist || flist->count == 0) {
 338                 exit_cleanup(0);
 339         }
 340
 341         send_files(flist,f_out,f_in);
 342         io_flush();
 343         report(f_out);
 344         if (remote_version >= 24) {
 345                 /* final goodbye message */
 346                 read_int(f_in);
 347         }
 348         io_flush();
 349         exit_cleanup(0);
 350 }
 351
 352
 353 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 354 {
 355         int pid;
 356         int status=0;
 357         int recv_pipe[2];
 358         int error_pipe[2];
 359         extern int preserve_hard_links;
 360         extern int delete_after;
 361         extern int recurse;
 362         extern int delete_mode;
 363         extern int remote_version;
 364
 365         if (preserve_hard_links)
 366                 init_hard_links(flist);
 367
 368         if (!delete_after) {
 369                 /* I moved this here from recv_files() to prevent a race condition */
 370                 if (recurse && delete_mode && !local_name && flist->count>0) {
 371                         delete_files(flist);
 372                 }
 373         }
 374
 375         if (fd_pair(recv_pipe) < 0) {
 376                 rprintf(FERROR,"pipe failed in do_recv\n");
 377                 exit_cleanup(RERR_SOCKETIO);
 378         }
 379
 380         if (fd_pair(error_pipe) < 0) {
 381                 rprintf(FERROR,"error pipe failed in do_recv\n");
 382                 exit_cleanup(RERR_SOCKETIO);
 383         }
 384
 385         io_flush();
 386
 387         if ((pid=do_fork()) == 0) {
 388                 close(recv_pipe[0]);
 389                 close(error_pipe[0]);
 390                 if (f_in != f_out) close(f_out);
 391
 392                 /* we can't let two processes write to the socket at one time */
 393                 io_multiplexing_close();
 394
 395                 /* set place to send errors */
 396                 set_error_fd(error_pipe[1]);
 397
 398                 recv_files(f_in,flist,local_name,recv_pipe[1]);
 399                 io_flush();
 400                 report(f_in);
 401
 402                 write_int(recv_pipe[1],1);
 403                 close(recv_pipe[1]);
 404                 io_flush();
 405                 /* finally we go to sleep until our parent kills us
 406                    with a USR2 signal. We sleep for a short time as on
 407                    some OSes a signal won't interrupt a sleep! */
 408                 while (msleep(20))
 409                         ;
 410         }
 411
 412         close(recv_pipe[1]);
 413         close(error_pipe[1]);
 414         if (f_in != f_out) close(f_in);
 415
 416         io_start_buffering(f_out);
 417
 418         io_set_error_fd(error_pipe[0]);
 419
 420         generate_files(f_out,flist,local_name,recv_pipe[0]);
 421
 422         read_int(recv_pipe[0]);
 423         close(recv_pipe[0]);
 424         if (remote_version >= 24) {
 425                 /* send a final goodbye message */
 426                 write_int(f_out, -1);
 427         }
 428         io_flush();
 429
 430         kill(pid, SIGUSR2);
 431         wait_process(pid, &status);
 432         return status;
 433 }
 434
 435
 436 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 437 {
 438         int status;
 439         struct file_list *flist;
 440         char *local_name=NULL;
 441         char *dir = NULL;
 442         extern int delete_mode;
 443         extern int delete_excluded;
 444         extern int am_daemon;
 445         extern int module_id;
 446         extern int am_sender;
 447         extern int read_batch;
 448         extern struct file_list *batch_flist;
 449
 450         if (verbose > 2)
 451                 rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
 452
 453         if (am_daemon && lp_read_only(module_id) && !am_sender) {
 454                 rprintf(FERROR,"ERROR: module is read only\n");
 455                 exit_cleanup(RERR_SYNTAX);
 456                 return;
 457         }
 458
 459
 460         if (argc > 0) {
 461                 dir = argv[0];
 462                 argc--;
 463                 argv++;
 464                 if (!am_daemon && !push_dir(dir, 0)) {
 465                         rprintf(FERROR,"push_dir %s : %s (4)\n",
 466                                 dir,strerror(errno));
 467                         exit_cleanup(RERR_FILESELECT);
 468                 }
 469         }
 470
 471         if (delete_mode && !delete_excluded)
 472                 recv_exclude_list(f_in);
 473
 474         if (read_batch)
 475             flist = batch_flist;
 476         else
 477             flist = recv_file_list(f_in);
 478         if (!flist) {
 479                 rprintf(FERROR,"server_recv: recv_file_list error\n");
 480                 exit_cleanup(RERR_FILESELECT);
 481         }
 482
 483         if (argc > 0) {
 484                 if (strcmp(dir,".")) {
 485                         argv[0] += strlen(dir);
 486                         if (argv[0][0] == '/') argv[0]++;
 487                 }
 488                 local_name = get_local_name(flist,argv[0]);
 489         }
 490
 491         status = do_recv(f_in,f_out,flist,local_name);
 492         exit_cleanup(status);
 493 }
 494
 495
 496 void start_server(int f_in, int f_out, int argc, char *argv[])
 497 {
 498         extern int cvs_exclude;
 499         extern int am_sender;
 500         extern int remote_version;
 501         extern int read_batch;
 502
 503         setup_protocol(f_out, f_in);
 504
 505         set_nonblocking(f_in);
 506         set_nonblocking(f_out);
 507
 508         if (remote_version >= 23)
 509                 io_start_multiplex_out(f_out);
 510
 511         if (am_sender) {
 512                 if (!read_batch) {
 513                     recv_exclude_list(f_in);
 514                     if (cvs_exclude)
 515                         add_cvs_excludes();
 516                 }
 517                 do_server_sender(f_in, f_out, argc, argv);
 518         } else {
 519                 do_server_recv(f_in, f_out, argc, argv);
 520         }
 521         exit_cleanup(0);
 522 }
 523
 524
 525 /*
 526  * This is called once the connection has been negotiated.  It is used
 527  * for rsyncd, remote-shell, and local connections.
 528  */
 529 int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[])
 530 {
 531         struct file_list *flist = NULL;
 532         int status = 0, status2 = 0;
 533         char *local_name = NULL;
 534         extern int am_sender;
 535         extern int remote_version;
 536         extern pid_t cleanup_child_pid;
 537         extern int write_batch;
 538         extern int read_batch;
 539         extern struct file_list *batch_flist;
 540
 541         cleanup_child_pid = pid;
 542         if (read_batch)
 543             flist = batch_flist;
 544
 545         set_nonblocking(f_in);
 546         set_nonblocking(f_out);
 547
 548         setup_protocol(f_out,f_in);
 549
 550         if (remote_version >= 23)
 551                 io_start_multiplex_in(f_in);
 552
 553         if (am_sender) {
 554                 extern int cvs_exclude;
 555                 extern int delete_mode;
 556                 extern int delete_excluded;
 557                 if (cvs_exclude)
 558                         add_cvs_excludes();
 559                 if (delete_mode && !delete_excluded)
 560                         send_exclude_list(f_out);
 561                 if (!read_batch) /*  dw -- don't write to pipe */
 562                     flist = send_file_list(f_out,argc,argv);
 563                 if (verbose > 3)
 564                         rprintf(FINFO,"file list sent\n");
 565
 566                 send_files(flist,f_out,f_in);
 567                 if (remote_version >= 24) {
 568                         /* final goodbye message */
 569                         read_int(f_in);
 570                 }
 571                 if (pid != -1) {
 572                         if (verbose > 3)
 573                                 rprintf(FINFO,"client_run waiting on %d\n", (int) pid);
 574                         io_flush();
 575                         wait_process(pid, &status);
 576                 }
 577                 report(-1);
 578                 exit_cleanup(status);
 579         }
 580
 581         if (argc == 0) {
 582                 extern int list_only;
 583                 list_only = 1;
 584         }
 585
 586         if (!write_batch)
 587             send_exclude_list(f_out);
 588
 589         flist = recv_file_list(f_in);
 590         if (!flist || flist->count == 0) {
 591                 rprintf(FINFO, "client: nothing to do: "
 592                         "perhaps you need to specify some filenames or "
 593                         "the --recursive option?\n");
 594                 exit_cleanup(0);
 595         }
 596
 597         local_name = get_local_name(flist,argv[0]);
 598
 599         status2 = do_recv(f_in,f_out,flist,local_name);
 600
 601         if (pid != -1) {
 602                 if (verbose > 3)
 603                         rprintf(FINFO,"client_run2 waiting on %d\n", (int) pid);
 604                 io_flush();
 605                 wait_process(pid, &status);
 606         }
 607
 608         return MAX(status, status2);
 609 }
 610
 611 static char *find_colon(char *s)
 612 {
 613         char *p, *p2;
 614
 615         p = strchr(s,':');
 616         if (!p) return NULL;
 617
 618         /* now check to see if there is a / in the string before the : - if there is then
 619            discard the colon on the assumption that the : is part of a filename */
 620         p2 = strchr(s,'/');
 621         if (p2 && p2 < p) return NULL;
 622
 623         return p;
 624 }
 625
 626
 627 static int copy_argv (char *argv[])
 628 {
 629         int i;
 630
 631         for (i = 0; argv[i]; i++) {
 632                 if (!(argv[i] = strdup(argv[i]))) {
 633                         rprintf (FERROR, "out of memory at %s(%d)\n",
 634                                  __FILE__, __LINE__);
 635                         return RERR_MALLOC;
 636                 }
 637         }
 638
 639         return 0;
 640 }
 641
 642
 643 /*
 644  * Start a client for either type of remote connection.  Work out
 645  * whether the arguments request a remote shell or rsyncd connection,
 646  * and call the appropriate connection function, then run_client.
 647  *
 648  * Calls either start_socket_client (for sockets) or do_cmd and
 649  * client_run (for ssh).
 650  */
 651 static int start_client(int argc, char *argv[])
 652 {
 653         char *p;
 654         char *shell_machine = NULL;
 655         char *shell_path = NULL;
 656         char *shell_user = NULL;
 657         int ret;
 658         pid_t pid;
 659         int f_in,f_out;
 660         extern int local_server;
 661         extern int am_sender;
 662         extern char *shell_cmd;
 663         extern int rsync_port;
 664         extern int whole_file;
 665         extern int write_batch;
 666         extern int read_batch;
 667         int rc;
 668
 669         /* Don't clobber argv[] so that ps(1) can still show the right
 670            command line. */
 671         if ((rc = copy_argv (argv)))
 672                 return rc;
 673
 674         if (strncasecmp(URL_PREFIX, argv[0], strlen(URL_PREFIX)) == 0) {
 675                 char *host, *path;
 676
 677                 host = argv[0] + strlen(URL_PREFIX);
 678                 p = strchr(host,'/');
 679                 if (p) {
 680                         *p = 0;
 681                         path = p+1;
 682                 } else {
 683                         path="";
 684                 }
 685                 p = strchr(host,':');
 686                 if (p) {
 687                         rsync_port = atoi(p+1);
 688                         *p = 0;
 689                 }
 690                 return start_socket_client(host, path, argc-1, argv+1);
 691         }
 692
 693         if (!read_batch) {
 694             p = find_colon(argv[0]);
 695
 696         if (p) {
 697                 if (p[1] == ':') {
 698                         *p = 0;
 699                         return start_socket_client(argv[0], p+2, argc-1, argv+1);
 700                 }
 701
 702                 if (argc < 1) {
 703                         usage(FERROR);
 704                         exit_cleanup(RERR_SYNTAX);
 705                 }
 706
 707                 am_sender = 0;
 708                 *p = 0;
 709                 shell_machine = argv[0];
 710                 shell_path = p+1;
 711                 argc--;
 712                 argv++;
 713         } else {
 714                 am_sender = 1;
 715
 716                 p = find_colon(argv[argc-1]);
 717                 if (!p) {
 718                         local_server = 1;
 719                         /*
 720                          * disable "rsync algorithm" when both sides local,
 721                          * except when creating a batch update
 722                          */
 723                         if (!write_batch && whole_file == -1)
 724                                 whole_file = 1;
 725                 } else if (p[1] == ':') {
 726                         *p = 0;
 727                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
 728                 }
 729
 730                 if (argc < 2) {
 731                         usage(FERROR);
 732                         exit_cleanup(RERR_SYNTAX);
 733                 }
 734
 735                 if (local_server) {
 736                         shell_machine = NULL;
 737                         shell_path = argv[argc-1];
 738                 } else {
 739                         *p = 0;
 740                         shell_machine = argv[argc-1];
 741                         shell_path = p+1;
 742                 }
 743                 argc--;
 744         }
 745         } else {
 746             am_sender = 1;
 747             local_server = 1;
 748             shell_path = argv[argc-1];
 749         }
 750
 751         if (shell_machine) {
 752                 p = strchr(shell_machine,'@');
 753                 if (p) {
 754                         *p = 0;
 755                         shell_user = shell_machine;
 756                         shell_machine = p+1;
 757                 }
 758         }
 759
 760         if (verbose > 3) {
 761                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 762                         shell_cmd?shell_cmd:"",
 763                         shell_machine?shell_machine:"",
 764                         shell_user?shell_user:"",
 765                         shell_path?shell_path:"");
 766         }
 767
 768         if (!am_sender && argc > 1) {
 769                 usage(FERROR);
 770                 exit_cleanup(RERR_SYNTAX);
 771         }
 772
 773         if (argc == 0 && !am_sender) {
 774                 extern int list_only;
 775                 list_only = 1;
 776         }
 777
 778         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 779
 780         ret = client_run(f_in, f_out, pid, argc, argv);
 781
 782         fflush(stdout);
 783         fflush(stderr);
 784
 785         return ret;
 786 }
 787
 788
 789 static RETSIGTYPE sigusr1_handler(int UNUSED(val)) {
 790         exit_cleanup(RERR_SIGNAL);
 791 }
 792
 793 static RETSIGTYPE sigusr2_handler(int UNUSED(val)) {
 794         extern int log_got_error;
 795         if (log_got_error) _exit(RERR_PARTIAL);
 796         _exit(0);
 797 }
 798
 799 static RETSIGTYPE sigchld_handler(int UNUSED(val)) {
 800 #ifdef WNOHANG
 801         while (waitpid(-1, NULL, WNOHANG) > 0) ;
 802 #endif
 803 }
 804
 805 int main(int argc,char *argv[])
 806 {
 807         extern int am_root;
 808         extern int orig_umask;
 809         extern int dry_run;
 810         extern int am_daemon;
 811         extern int am_server;
 812         int ret;
 813         extern int write_batch;
 814         int orig_argc;
 815         char **orig_argv;
 816
 817         orig_argc = argc;
 818         orig_argv = argv;
 819
 820         signal(SIGUSR1, sigusr1_handler);
 821         signal(SIGUSR2, sigusr2_handler);
 822         signal(SIGCHLD, sigchld_handler);
 823
 824         starttime = time(NULL);
 825         am_root = (getuid() == 0);
 826
 827         memset(&stats, 0, sizeof(stats));
 828
 829         if (argc < 2) {
 830                 usage(FERROR);
 831                 exit_cleanup(RERR_SYNTAX);
 832         }
 833
 834         /* we set a 0 umask so that correct file permissions can be
 835            carried across */
 836         orig_umask = (int)umask(0);
 837
 838         if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
 839                 /* FIXME: We ought to call the same error-handling
 840                  * code here, rather than relying on getopt. */
 841                 option_error();
 842                 exit_cleanup(RERR_SYNTAX);
 843         }
 844
 845         signal(SIGINT,SIGNAL_CAST sig_int);
 846         signal(SIGHUP,SIGNAL_CAST sig_int);
 847         signal(SIGTERM,SIGNAL_CAST sig_int);
 848
 849         /* Ignore SIGPIPE; we consistently check error codes and will
 850          * see the EPIPE. */
 851         signal(SIGPIPE, SIG_IGN);
 852
 853         /* Initialize push_dir here because on some old systems getcwd
 854            (implemented by forking "pwd" and reading its output) doesn't
 855            work when there are other child processes.  Also, on all systems
 856            that implement getcwd that way "pwd" can't be found after chroot. */
 857         push_dir(NULL,0);
 858
 859         if (write_batch && !am_server) {
 860             write_batch_argvs_file(orig_argc, orig_argv);
 861         }
 862
 863         if (am_daemon) {
 864                 return daemon_main();
 865         }
 866
 867         if (argc < 1) {
 868                 usage(FERROR);
 869                 exit_cleanup(RERR_SYNTAX);
 870         }
 871
 872         if (dry_run)
 873                 verbose = MAX(verbose,1);
 874
 875 #ifndef SUPPORT_LINKS
 876         if (!am_server && preserve_links) {
 877                 rprintf(FERROR,"ERROR: symbolic links not supported\n");
 878                 exit_cleanup(RERR_UNSUPPORTED);
 879         }
 880 #endif
 881
 882         if (am_server) {
 883                 set_nonblocking(STDIN_FILENO);
 884                 set_nonblocking(STDOUT_FILENO);
 885                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 886         }
 887
 888         ret = start_client(argc, argv);
 889         if (ret == -1)
 890             exit_cleanup(RERR_STARTCLIENT);
 891         else
 892             exit_cleanup(ret);
 893         return ret;
 894 }