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 int verbose = 0;
  23 int always_checksum = 0;
  24 time_t starttime = 0;
  25 int64 total_size = 0;
  26 int block_size=BLOCK_SIZE;
  27
  28 char *backup_suffix = BACKUP_SUFFIX;
  29 char *tmpdir = NULL;
  30
  31 static char *rsync_path = RSYNC_NAME;
  32
  33 int make_backups = 0;
  34 int whole_file = 0;
  35 int copy_links = 0;
  36 int preserve_links = 0;
  37 int preserve_hard_links = 0;
  38 int preserve_perms = 0;
  39 int preserve_devices = 0;
  40 int preserve_uid = 0;
  41 int preserve_gid = 0;
  42 int preserve_times = 0;
  43 int update_only = 0;
  44 int cvs_exclude = 0;
  45 int dry_run=0;
  46 int local_server=0;
  47 int ignore_times=0;
  48 int delete_mode=0;
  49 int one_file_system=0;
  50 int remote_version=0;
  51 int sparse_files=0;
  52 int do_compression=0;
  53 int am_root=0;
  54 int orig_umask=0;
  55 int relative_paths=0;
  56 int numeric_ids = 0;
  57 int force_delete = 0;
  58 int io_timeout = 0;
  59 int io_error = 0;
  60 int read_only = 0;
  61 static int module_id;
  62
  63 static int port = RSYNC_PORT;
  64
  65 static char *shell_cmd;
  66
  67 extern int csum_length;
  68
  69 int am_server = 0;
  70 int am_sender=0;
  71 int recurse = 0;
  72 int am_daemon=0;
  73
  74 static void usage(int fd);
  75
  76 static void report(int f)
  77 {
  78   int64 in,out,tsize;
  79   time_t t = time(NULL);
  80
  81   if (!verbose) return;
  82
  83   if (am_server && am_sender) {
  84     write_longint(f,read_total());
  85     write_longint(f,write_total());
  86     write_longint(f,total_size);
  87     write_flush(f);
  88     return;
  89   }
  90
  91   if (am_sender) {
  92     in = read_total();
  93     out = write_total();
  94     tsize = total_size;
  95   } else {
  96     in = read_longint(f);
  97     out = read_longint(f);
  98     tsize = read_longint(f);
  99   }
 100
 101   printf("wrote %.0f bytes  read %.0f bytes  %.2f bytes/sec\n",
 102          (double)out,(double)in,(in+out)/(0.5 + (t-starttime)));
 103   printf("total size is %.0f  speedup is %.2f\n",
 104          (double)tsize,(1.0*tsize)/(in+out));
 105 }
 106
 107
 108 static void server_options(char **args,int *argc)
 109 {
 110   int ac = *argc;
 111   static char argstr[50];
 112   static char bsize[30];
 113   static char iotime[30];
 114   int i, x;
 115
 116   args[ac++] = "--server";
 117
 118   if (!am_sender)
 119     args[ac++] = "--sender";
 120
 121   x = 1;
 122   argstr[0] = '-';
 123   for (i=0;i<verbose;i++)
 124     argstr[x++] = 'v';
 125   if (make_backups)
 126     argstr[x++] = 'b';
 127   if (update_only)
 128     argstr[x++] = 'u';
 129   if (dry_run)
 130     argstr[x++] = 'n';
 131   if (preserve_links)
 132     argstr[x++] = 'l';
 133   if (copy_links)
 134     argstr[x++] = 'L';
 135   if (whole_file)
 136     argstr[x++] = 'W';
 137   if (preserve_hard_links)
 138     argstr[x++] = 'H';
 139   if (preserve_uid)
 140     argstr[x++] = 'o';
 141   if (preserve_gid)
 142     argstr[x++] = 'g';
 143   if (preserve_devices)
 144     argstr[x++] = 'D';
 145   if (preserve_times)
 146     argstr[x++] = 't';
 147   if (preserve_perms)
 148     argstr[x++] = 'p';
 149   if (recurse)
 150     argstr[x++] = 'r';
 151   if (always_checksum)
 152     argstr[x++] = 'c';
 153   if (cvs_exclude)
 154     argstr[x++] = 'C';
 155   if (ignore_times)
 156     argstr[x++] = 'I';
 157   if (relative_paths)
 158     argstr[x++] = 'R';
 159   if (one_file_system)
 160     argstr[x++] = 'x';
 161   if (sparse_files)
 162     argstr[x++] = 'S';
 163   if (do_compression)
 164     argstr[x++] = 'z';
 165   argstr[x] = 0;
 166
 167   if (x != 1) args[ac++] = argstr;
 168
 169   if (block_size != BLOCK_SIZE) {
 170     sprintf(bsize,"-B%d",block_size);
 171     args[ac++] = bsize;
 172   }
 173
 174   if (io_timeout) {
 175     sprintf(iotime,"--timeout=%d",io_timeout);
 176     args[ac++] = iotime;
 177   }
 178
 179   if (strcmp(backup_suffix, BACKUP_SUFFIX)) {
 180           args[ac++] = "--suffix";
 181           args[ac++] = backup_suffix;
 182   }
 183
 184   if (delete_mode)
 185     args[ac++] = "--delete";
 186
 187   if (force_delete)
 188     args[ac++] = "--force";
 189
 190   if (numeric_ids)
 191     args[ac++] = "--numeric-ids";
 192
 193   if (tmpdir) {
 194           args[ac++] = "--temp-dir";
 195           args[ac++] = tmpdir;
 196   }
 197
 198   *argc = ac;
 199 }
 200
 201
 202
 203 static int do_cmd(char *cmd,char *machine,char *user,char *path,int *f_in,int *f_out)
 204 {
 205         char *args[100];
 206         int i,argc=0, ret;
 207         char *tok,*dir=NULL;
 208
 209         if (!local_server) {
 210                 if (!cmd)
 211                         cmd = getenv(RSYNC_RSH_ENV);
 212                 if (!cmd)
 213                         cmd = RSYNC_RSH;
 214                 cmd = strdup(cmd);
 215                 if (!cmd)
 216                         goto oom;
 217
 218                 for (tok=strtok(cmd," ");tok;tok=strtok(NULL," ")) {
 219                         args[argc++] = tok;
 220                 }
 221
 222 #if HAVE_REMSH
 223                 /* remsh (on HPUX) takes the arguments the other way around */
 224                 args[argc++] = machine;
 225                 if (user) {
 226                         args[argc++] = "-l";
 227                         args[argc++] = user;
 228                 }
 229 #else
 230                 if (user) {
 231                         args[argc++] = "-l";
 232                         args[argc++] = user;
 233                 }
 234                 args[argc++] = machine;
 235 #endif
 236
 237                 args[argc++] = rsync_path;
 238
 239                 server_options(args,&argc);
 240         }
 241
 242         args[argc++] = ".";
 243
 244         if (path && *path)
 245                 args[argc++] = path;
 246
 247         args[argc] = NULL;
 248
 249         if (verbose > 3) {
 250                 rprintf(FINFO,"cmd=");
 251                 for (i=0;i<argc;i++)
 252                         rprintf(FINFO,"%s ",args[i]);
 253                 rprintf(FINFO,"\n");
 254         }
 255
 256         if (local_server) {
 257                 ret = local_child(argc, args, f_in, f_out);
 258         } else {
 259                 ret = piped_child(args,f_in,f_out);
 260         }
 261
 262         if (dir) free(dir);
 263
 264         return ret;
 265
 266 oom:
 267         out_of_memory("do_cmd");
 268         return 0; /* not reached */
 269 }
 270
 271
 272
 273
 274 static char *get_local_name(struct file_list *flist,char *name)
 275 {
 276   STRUCT_STAT st;
 277
 278   if (do_stat(name,&st) == 0) {
 279     if (S_ISDIR(st.st_mode)) {
 280       if (chdir(name) != 0) {
 281         rprintf(FERROR,"chdir %s : %s (1)\n",name,strerror(errno));
 282         exit_cleanup(1);
 283       }
 284       return NULL;
 285     }
 286     if (flist->count > 1) {
 287       rprintf(FERROR,"ERROR: destination must be a directory when copying more than 1 file\n");
 288       exit_cleanup(1);
 289     }
 290     return name;
 291   }
 292
 293   if (flist->count == 1)
 294     return name;
 295
 296   if (!name)
 297     return NULL;
 298
 299   if (do_mkdir(name,0777 & ~orig_umask) != 0) {
 300     rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
 301     exit_cleanup(1);
 302   } else {
 303     rprintf(FINFO,"created directory %s\n",name);
 304   }
 305
 306   if (chdir(name) != 0) {
 307     rprintf(FERROR,"chdir %s : %s (2)\n",name,strerror(errno));
 308     exit_cleanup(1);
 309   }
 310
 311   return NULL;
 312 }
 313
 314
 315
 316
 317 static void do_server_sender(int f_in, int f_out, int argc,char *argv[])
 318 {
 319   int i;
 320   struct file_list *flist;
 321   char *dir = argv[0];
 322
 323   if (verbose > 2)
 324     rprintf(FINFO,"server_sender starting pid=%d\n",(int)getpid());
 325
 326   if (!relative_paths && chdir(dir) != 0) {
 327           rprintf(FERROR,"chdir %s: %s (3)\n",dir,strerror(errno));
 328           exit_cleanup(1);
 329   }
 330   argc--;
 331   argv++;
 332
 333   if (strcmp(dir,".")) {
 334           int l = strlen(dir);
 335           if (strcmp(dir,"/") == 0)
 336                   l = 0;
 337           for (i=0;i<argc;i++)
 338                   argv[i] += l+1;
 339   }
 340
 341   if (am_daemon) {
 342           char *name = lp_name(module_id);
 343           int l = strlen(name);
 344           for (i=0;i<argc;i++) {
 345                   if (strncmp(argv[i], name, l) == 0) {
 346                           argv[i] += l;
 347                           if (!*argv[i]) argv[i] = ".";
 348                   }
 349           }
 350   }
 351
 352   if (argc == 0 && recurse) {
 353           argc=1;
 354           argv--;
 355           argv[0] = ".";
 356   }
 357
 358   rprintf(FINFO,"sending file list\n");
 359
 360   flist = send_file_list(f_out,argc,argv);
 361   send_files(flist,f_out,f_in);
 362   report(f_out);
 363   exit_cleanup(0);
 364 }
 365
 366
 367 static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name)
 368 {
 369   int pid;
 370   int status=0;
 371   int recv_pipe[2];
 372
 373   if (preserve_hard_links)
 374     init_hard_links(flist);
 375
 376   if (pipe(recv_pipe) < 0) {
 377     rprintf(FERROR,"pipe failed in do_recv\n");
 378     exit(1);
 379   }
 380
 381
 382   if ((pid=do_fork()) == 0) {
 383     recv_files(f_in,flist,local_name,recv_pipe[1]);
 384     if (verbose > 2)
 385       rprintf(FINFO,"receiver read %ld\n",(long)read_total());
 386     exit_cleanup(0);
 387   }
 388
 389   generate_files(f_out,flist,local_name,recv_pipe[0]);
 390
 391   waitpid(pid, &status, 0);
 392
 393   return status;
 394 }
 395
 396
 397 static void do_server_recv(int f_in, int f_out, int argc,char *argv[])
 398 {
 399   int status;
 400   struct file_list *flist;
 401   char *local_name=NULL;
 402   char *dir = NULL;
 403
 404   if (verbose > 2)
 405     rprintf(FINFO,"server_recv(%d) starting pid=%d\n",argc,(int)getpid());
 406
 407   if (am_daemon) {
 408           char *name = lp_name(module_id);
 409           int i, l = strlen(name);
 410           for (i=0;i<argc;i++) {
 411                   if (strncmp(argv[i], name, l) == 0) {
 412                           argv[i] += l;
 413                           if (!*argv[i]) argv[i] = ".";
 414                   }
 415                   rprintf(FINFO,"argv[%d]=%s\n", i, argv[i]);
 416           }
 417   }
 418
 419   if (argc > 0) {
 420           dir = argv[0];
 421           argc--;
 422           argv++;
 423           if (!am_daemon && chdir(dir) != 0) {
 424                   rprintf(FERROR,"chdir %s : %s (4)\n",
 425                           dir,strerror(errno));
 426                   exit_cleanup(1);
 427           }
 428   }
 429
 430   if (delete_mode)
 431     recv_exclude_list(f_in);
 432
 433   flist = recv_file_list(f_in);
 434   if (!flist || flist->count == 0) {
 435     rprintf(FERROR,"nothing to do\n");
 436     exit_cleanup(1);
 437   }
 438
 439   if (argc > 0) {
 440           if (strcmp(dir,".")) {
 441                   argv[0] += strlen(dir);
 442                   if (argv[0][0] == '/') argv[0]++;
 443           }
 444           local_name = get_local_name(flist,argv[0]);
 445   }
 446
 447   status = do_recv(f_in,f_out,flist,local_name);
 448   exit_cleanup(status);
 449 }
 450
 451
 452 void start_server(int f_in, int f_out, int argc, char *argv[])
 453 {
 454       setup_protocol(f_out, f_in);
 455
 456       if (am_sender) {
 457               recv_exclude_list(f_in);
 458               if (cvs_exclude)
 459                       add_cvs_excludes();
 460               do_server_sender(f_in, f_out, argc, argv);
 461       } else {
 462               do_server_recv(f_in, f_out, argc, argv);
 463       }
 464       exit_cleanup(0);
 465 }
 466
 467 static int client_run(int f_in, int f_out, int pid, int argc, char *argv[])
 468 {
 469         struct file_list *flist;
 470         int status = 0, status2 = 0;
 471         char *local_name = NULL;
 472
 473         setup_protocol(f_out,f_in);
 474
 475         if (am_sender) {
 476                 if (cvs_exclude)
 477                         add_cvs_excludes();
 478                 if (delete_mode)
 479                         send_exclude_list(f_out);
 480                 flist = send_file_list(f_out,argc,argv);
 481                 if (verbose > 3)
 482                         rprintf(FINFO,"file list sent\n");
 483                 send_files(flist,f_out,f_in);
 484                 if (pid != -1) {
 485                         if (verbose > 3)
 486                                 rprintf(FINFO,"waiting on %d\n",pid);
 487                         waitpid(pid, &status, 0);
 488                 }
 489                 report(-1);
 490                 exit_cleanup(status);
 491         }
 492
 493         send_exclude_list(f_out);
 494
 495         flist = recv_file_list(f_in);
 496         if (!flist || flist->count == 0) {
 497                 rprintf(FINFO,"nothing to do\n");
 498                 exit_cleanup(0);
 499         }
 500
 501         local_name = get_local_name(flist,argv[0]);
 502
 503         status2 = do_recv(f_in,f_out,flist,local_name);
 504
 505         report(f_in);
 506
 507         if (pid != -1) {
 508                 waitpid(pid, &status, 0);
 509         }
 510
 511         return status | status2;
 512 }
 513
 514
 515 int start_socket_client(char *host, char *path, int argc, char *argv[])
 516 {
 517         int fd, i;
 518         char *sargs[MAX_ARGS];
 519         int sargc=0;
 520         char line[1024];
 521         char *p;
 522         int version;
 523
 524         fd = open_socket_out(host, port);
 525         if (fd == -1) {
 526                 exit_cleanup(1);
 527         }
 528
 529         server_options(sargs,&sargc);
 530
 531         sargs[sargc++] = ".";
 532
 533         if (path && *path)
 534                 sargs[sargc++] = path;
 535
 536         sargs[sargc] = NULL;
 537
 538         p = strchr(path,'/');
 539         if (p) *p = 0;
 540         io_printf(fd,"%s\n",path);
 541         if (p) *p = '/';
 542
 543         if (!read_line(fd, line, sizeof(line)-1)) {
 544                 return -1;
 545         }
 546
 547         if (sscanf(line,"RSYNCD %d", &version) != 1) {
 548                 return -1;
 549         }
 550
 551         while (1) {
 552                 if (!read_line(fd, line, sizeof(line)-1)) {
 553                         return -1;
 554                 }
 555                 if (strcmp(line,"RSYNCD: OK") == 0) break;
 556                 rprintf(FINFO,"%s\n", line);
 557         }
 558
 559         for (i=0;i<sargc;i++) {
 560                 io_printf(fd,"%s\n", sargs[i]);
 561         }
 562         io_printf(fd,"\n");
 563
 564 #if 0
 565         while (1) {
 566                 if (!read_line(fd, line, sizeof(line)-1)) {
 567                         return -1;
 568                 }
 569                 rprintf(FINFO,"%s\n", line);
 570         }
 571 #endif
 572
 573         return client_run(fd, fd, -1, argc, argv);
 574 }
 575
 576 int start_client(int argc, char *argv[])
 577 {
 578         char *p;
 579         char *shell_machine = NULL;
 580         char *shell_path = NULL;
 581         char *shell_user = NULL;
 582         int pid;
 583         int f_in,f_out;
 584
 585         p = strchr(argv[0],':');
 586
 587         if (p) {
 588                 if (p[1] == ':') {
 589                         *p = 0;
 590                         return start_socket_client(argv[0], p+2, argc-1, argv+1);
 591                 }
 592                 am_sender = 0;
 593                 *p = 0;
 594                 shell_machine = argv[0];
 595                 shell_path = p+1;
 596                 argc--;
 597                 argv++;
 598         } else {
 599                 am_sender = 1;
 600
 601                 p = strchr(argv[argc-1],':');
 602                 if (!p) {
 603                         local_server = 1;
 604                 } else if (p[1] == ':') {
 605                         *p = 0;
 606                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
 607                 }
 608
 609                 if (local_server) {
 610                         shell_machine = NULL;
 611                         shell_path = argv[argc-1];
 612                 } else {
 613                         *p = 0;
 614                         shell_machine = argv[argc-1];
 615                         shell_path = p+1;
 616                 }
 617                 argc--;
 618         }
 619
 620         if (shell_machine) {
 621                 p = strchr(shell_machine,'@');
 622                 if (p) {
 623                         *p = 0;
 624                         shell_user = shell_machine;
 625                         shell_machine = p+1;
 626                 }
 627         }
 628
 629         if (verbose > 3) {
 630                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
 631                         shell_cmd?shell_cmd:"",
 632                         shell_machine?shell_machine:"",
 633                         shell_user?shell_user:"",
 634                         shell_path?shell_path:"");
 635         }
 636
 637         if (!am_sender && argc != 1) {
 638                 usage(FERROR);
 639                 exit_cleanup(1);
 640         }
 641
 642         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
 643
 644 #if HAVE_SETLINEBUF
 645         setlinebuf(stdout);
 646         setlinebuf(stderr);
 647 #endif
 648
 649         return client_run(f_in, f_out, pid, argc, argv);
 650 }
 651
 652
 653 static void usage(int F)
 654 {
 655   rprintf(F,"rsync version %s Copyright Andrew Tridgell and Paul Mackerras\n\n",
 656           VERSION);
 657   rprintf(F,"Usage:\t%s [options] src user@host:dest\nOR",RSYNC_NAME);
 658   rprintf(F,"\t%s [options] user@host:src dest\n\n",RSYNC_NAME);
 659   rprintf(F,"Options:\n");
 660   rprintf(F,"-v, --verbose            increase verbosity\n");
 661   rprintf(F,"-c, --checksum           always checksum\n");
 662   rprintf(F,"-a, --archive            archive mode (same as -rlptDog)\n");
 663   rprintf(F,"-r, --recursive          recurse into directories\n");
 664   rprintf(F,"-R, --relative           use relative path names\n");
 665   rprintf(F,"-b, --backup             make backups (default ~ extension)\n");
 666   rprintf(F,"-u, --update             update only (don't overwrite newer files)\n");
 667   rprintf(F,"-l, --links              preserve soft links\n");
 668   rprintf(F,"-L, --copy-links         treat soft links like regular files\n");
 669   rprintf(F,"-H, --hard-links         preserve hard links\n");
 670   rprintf(F,"-p, --perms              preserve permissions\n");
 671   rprintf(F,"-o, --owner              preserve owner (root only)\n");
 672   rprintf(F,"-g, --group              preserve group\n");
 673   rprintf(F,"-D, --devices            preserve devices (root only)\n");
 674   rprintf(F,"-t, --times              preserve times\n");
 675   rprintf(F,"-S, --sparse             handle sparse files efficiently\n");
 676   rprintf(F,"-n, --dry-run            show what would have been transferred\n");
 677   rprintf(F,"-W, --whole-file         copy whole files, no incremental checks\n");
 678   rprintf(F,"-x, --one-file-system    don't cross filesystem boundaries\n");
 679   rprintf(F,"-B, --block-size SIZE    checksum blocking size\n");
 680   rprintf(F,"-e, --rsh COMMAND        specify rsh replacement\n");
 681   rprintf(F,"    --rsync-path PATH    specify path to rsync on the remote machine\n");
 682   rprintf(F,"-C, --cvs-exclude        auto ignore files in the same way CVS does\n");
 683   rprintf(F,"    --delete             delete files that don't exist on the sending side\n");
 684   rprintf(F,"    --force              force deletion of directories even if not empty\n");
 685   rprintf(F,"    --numeric-ids        don't map uid/gid values by user/group name\n");
 686   rprintf(F,"    --timeout TIME       set IO timeout in seconds\n");
 687   rprintf(F,"-I, --ignore-times       don't exclude files that match length and time\n");
 688   rprintf(F,"-T  --temp-dir DIR       create temporary files in directory DIR\n");
 689   rprintf(F,"-z, --compress           compress file data\n");
 690   rprintf(F,"    --exclude FILE       exclude file FILE\n");
 691   rprintf(F,"    --exclude-from FILE  exclude files listed in FILE\n");
 692   rprintf(F,"    --suffix SUFFIX      override backup suffix\n");
 693   rprintf(F,"    --version            print version number\n");
 694
 695   rprintf(F,"\n");
 696   rprintf(F,"the backup suffix defaults to %s\n",BACKUP_SUFFIX);
 697   rprintf(F,"the block size defaults to %d\n",BLOCK_SIZE);
 698 }
 699
 700 enum {OPT_VERSION,OPT_SUFFIX,OPT_SENDER,OPT_SERVER,OPT_EXCLUDE,
 701       OPT_EXCLUDE_FROM,OPT_DELETE,OPT_NUMERIC_IDS,OPT_RSYNC_PATH,
 702       OPT_FORCE,OPT_TIMEOUT,OPT_DAEMON};
 703
 704 static char *short_options = "oblLWHpguDCtcahvrRIxnSe:B:T:z";
 705
 706 static struct option long_options[] = {
 707   {"version",     0,     0,    OPT_VERSION},
 708   {"server",      0,     0,    OPT_SERVER},
 709   {"sender",      0,     0,    OPT_SENDER},
 710   {"delete",      0,     0,    OPT_DELETE},
 711   {"force",       0,     0,    OPT_FORCE},
 712   {"numeric-ids", 0,     0,    OPT_NUMERIC_IDS},
 713   {"exclude",     1,     0,    OPT_EXCLUDE},
 714   {"exclude-from",1,     0,    OPT_EXCLUDE_FROM},
 715   {"rsync-path",  1,     0,    OPT_RSYNC_PATH},
 716   {"one-file-system",0,  0,    'x'},
 717   {"ignore-times",0,     0,    'I'},
 718   {"help",        0,     0,    'h'},
 719   {"dry-run",     0,     0,    'n'},
 720   {"sparse",      0,     0,    'S'},
 721   {"cvs-exclude", 0,     0,    'C'},
 722   {"archive",     0,     0,    'a'},
 723   {"checksum",    0,     0,    'c'},
 724   {"backup",      0,     0,    'b'},
 725   {"update",      0,     0,    'u'},
 726   {"verbose",     0,     0,    'v'},
 727   {"recursive",   0,     0,    'r'},
 728   {"relative",    0,     0,    'R'},
 729   {"devices",     0,     0,    'D'},
 730   {"perms",       0,     0,    'p'},
 731   {"links",       0,     0,    'l'},
 732   {"copy-links",  0,     0,    'L'},
 733   {"whole-file",  0,     0,    'W'},
 734   {"hard-links",  0,     0,    'H'},
 735   {"owner",       0,     0,    'o'},
 736   {"group",       0,     0,    'g'},
 737   {"times",       0,     0,    't'},
 738   {"rsh",         1,     0,    'e'},
 739   {"suffix",      1,     0,    OPT_SUFFIX},
 740   {"block-size",  1,     0,    'B'},
 741   {"timeout",     1,     0,    OPT_TIMEOUT},
 742   {"temp-dir",    1,     0,    'T'},
 743   {"compress",    0,     0,    'z'},
 744   {"daemon",      0,     0,    OPT_DAEMON},
 745   {0,0,0,0}};
 746
 747 RETSIGTYPE sigusr1_handler(int val) {
 748         exit_cleanup(1);
 749 }
 750
 751
 752 static void parse_arguments(int argc, char *argv[])
 753 {
 754     int opt;
 755     int option_index;
 756
 757     while ((opt = getopt_long(argc, argv,
 758                               short_options, long_options, &option_index))
 759            != -1) {
 760       switch (opt)
 761         {
 762         case OPT_VERSION:
 763           printf("rsync version %s  protocol version %d\n",
 764                  VERSION,PROTOCOL_VERSION);
 765           exit_cleanup(0);
 766
 767         case OPT_SUFFIX:
 768           backup_suffix = optarg;
 769           break;
 770
 771         case OPT_RSYNC_PATH:
 772           rsync_path = optarg;
 773           break;
 774
 775         case 'I':
 776           ignore_times = 1;
 777           break;
 778
 779         case 'x':
 780           one_file_system=1;
 781           break;
 782
 783         case OPT_DELETE:
 784           delete_mode = 1;
 785           break;
 786
 787         case OPT_FORCE:
 788           force_delete = 1;
 789           break;
 790
 791         case OPT_NUMERIC_IDS:
 792           numeric_ids = 1;
 793           break;
 794
 795         case OPT_EXCLUDE:
 796           add_exclude(optarg);
 797           break;
 798
 799         case OPT_EXCLUDE_FROM:
 800           add_exclude_file(optarg,1);
 801           break;
 802
 803         case 'h':
 804           usage(FINFO);
 805           exit_cleanup(0);
 806
 807         case 'b':
 808           make_backups=1;
 809           break;
 810
 811         case 'n':
 812           dry_run=1;
 813           break;
 814
 815         case 'S':
 816           sparse_files=1;
 817           break;
 818
 819         case 'C':
 820           cvs_exclude=1;
 821           break;
 822
 823         case 'u':
 824           update_only=1;
 825           break;
 826
 827         case 'l':
 828           preserve_links=1;
 829           break;
 830
 831         case 'L':
 832           copy_links=1;
 833           break;
 834
 835         case 'W':
 836           whole_file=1;
 837           break;
 838
 839         case 'H':
 840 #if SUPPORT_HARD_LINKS
 841           preserve_hard_links=1;
 842 #else
 843           rprintf(FERROR,"ERROR: hard links not supported on this platform\n");
 844           exit_cleanup(1);
 845 #endif
 846           break;
 847
 848         case 'p':
 849           preserve_perms=1;
 850           break;
 851
 852         case 'o':
 853           preserve_uid=1;
 854           break;
 855
 856         case 'g':
 857           preserve_gid=1;
 858           break;
 859
 860         case 'D':
 861           preserve_devices=1;
 862           break;
 863
 864         case 't':
 865           preserve_times=1;
 866           break;
 867
 868         case 'c':
 869           always_checksum=1;
 870           break;
 871
 872         case 'v':
 873           verbose++;
 874           break;
 875
 876         case 'a':
 877           recurse=1;
 878 #if SUPPORT_LINKS
 879           preserve_links=1;
 880 #endif
 881           preserve_perms=1;
 882           preserve_times=1;
 883           preserve_gid=1;
 884           if (am_root) {
 885             preserve_devices=1;
 886             preserve_uid=1;
 887           }
 888           break;
 889
 890         case OPT_SERVER:
 891           am_server = 1;
 892           break;
 893
 894         case OPT_SENDER:
 895           if (!am_server) {
 896             usage(FERROR);
 897             exit_cleanup(1);
 898           }
 899           am_sender = 1;
 900           break;
 901
 902         case 'r':
 903           recurse = 1;
 904           break;
 905
 906         case 'R':
 907           relative_paths = 1;
 908           break;
 909
 910         case 'e':
 911           shell_cmd = optarg;
 912           break;
 913
 914         case 'B':
 915           block_size = atoi(optarg);
 916           break;
 917
 918         case OPT_TIMEOUT:
 919           io_timeout = atoi(optarg);
 920           break;
 921
 922         case 'T':
 923                 tmpdir = optarg;
 924                 break;
 925
 926         case 'z':
 927           do_compression = 1;
 928           break;
 929
 930         case OPT_DAEMON:
 931                 am_daemon = 1;
 932                 break;
 933
 934         default:
 935           /* rprintf(FERROR,"bad option -%c\n",opt); */
 936           exit_cleanup(1);
 937         }
 938     }
 939 }
 940
 941 static int rsync_module(int fd, int i)
 942 {
 943         int argc=0;
 944         char *argv[MAX_ARGS];
 945         char **argp;
 946         char line[1024];
 947
 948         module_id = i;
 949
 950         if (lp_read_only(i))
 951                 read_only = 1;
 952
 953         rprintf(FERROR,"rsyncd starting\n");
 954
 955         if (chroot(lp_path(i))) {
 956                 io_printf(fd,"ERROR: chroot failed\n");
 957                 return -1;
 958         }
 959
 960         if (chdir("/")) {
 961                 io_printf(fd,"ERROR: chdir failed\n");
 962                 return -1;
 963         }
 964
 965         if (setgid(lp_gid(i))) {
 966                 io_printf(fd,"ERROR: setgid failed\n");
 967                 return -1;
 968         }
 969
 970         if (setuid(lp_uid(i))) {
 971                 io_printf(fd,"ERROR: setuid failed\n");
 972                 return -1;
 973         }
 974
 975         io_printf(fd,"RSYNCD: OK\n");
 976
 977         argv[argc++] = "rsyncd";
 978
 979         while (1) {
 980                 if (!read_line(fd, line, sizeof(line)-1)) {
 981                         return -1;
 982                 }
 983
 984                 if (!*line) break;
 985
 986                 argv[argc] = strdup(line);
 987                 if (!argv[argc]) {
 988                         return -1;
 989                 }
 990
 991                 argc++;
 992                 if (argc == MAX_ARGS) {
 993                         return -1;
 994                 }
 995         }
 996
 997         parse_arguments(argc, argv);
 998
 999         /* don't allow the logs to be flooded too fast */
1000         if (verbose > 1) verbose = 1;
1001
1002         argc -= optind;
1003         argp = argv + optind;
1004         optind = 0;
1005
1006         start_server(fd, fd, argc, argp);
1007
1008         return 0;
1009 }
1010
1011 static void send_listing(int fd)
1012 {
1013         int n = lp_numservices();
1014         int i;
1015
1016         for (i=0;i<n;i++)
1017                 if (lp_list(i))
1018                     io_printf(fd, "%-15s\t%s\n", lp_name(i), lp_comment(i));
1019 }
1020
1021 /* this is called when a socket connection is established to a client
1022    and we want to start talking. The setup of the system is done from
1023    here */
1024 static int start_daemon(int fd)
1025 {
1026         char line[1024];
1027         char *motd;
1028
1029         set_socket_options(fd,"SO_KEEPALIVE");
1030
1031         io_printf(fd,"RSYNCD %d\n", PROTOCOL_VERSION);
1032
1033         motd = lp_motd_file();
1034         if (*motd) {
1035                 FILE *f = fopen(motd,"r");
1036                 while (f && !feof(f)) {
1037                         int len = fread(line, 1, sizeof(line)-1, f);
1038                         if (len > 0) {
1039                                 line[len] = 0;
1040                                 io_printf(fd,"%s", line);
1041                         }
1042                 }
1043                 if (f) fclose(f);
1044                 io_printf(fd,"\n");
1045         }
1046
1047         /* read a single line indicating the resource that is wanted */
1048         while (1) {
1049                 int i;
1050
1051                 line[0] = 0;
1052                 if (!read_line(fd, line, sizeof(line)-1)) {
1053                         return -1;
1054                 }
1055
1056                 if (!*line || strcmp(line,"#list")==0) {
1057                         send_listing(fd);
1058                         return -1;
1059                 }
1060
1061                 if (*line == '#') {
1062                         /* it's some sort of command that I don't understand */
1063                         io_printf(fd,"ERROR: Unknown command '%s'\n", line);
1064                         return -1;
1065                 }
1066
1067                 i = lp_number(line);
1068                 if (i == -1) {
1069                         io_printf(fd,"ERROR: Unknown module '%s'\n", line);
1070                         return -1;
1071                 }
1072
1073                 return rsync_module(fd, i);
1074         }
1075
1076         return 0;
1077 }
1078
1079
1080 static int daemon_main(void)
1081 {
1082         if (!lp_load(RSYNCD_CONF)) {
1083                 exit_cleanup(1);
1084         }
1085
1086         if (is_a_socket(STDIN_FILENO)) {
1087                 /* we are running via inetd */
1088                 return start_daemon(STDIN_FILENO);
1089         }
1090
1091         become_daemon();
1092
1093         return start_accept_loop(port, start_daemon);
1094 }
1095
1096 int main(int argc,char *argv[])
1097 {
1098
1099     signal(SIGUSR1, sigusr1_handler);
1100
1101     starttime = time(NULL);
1102     am_root = (getuid() == 0);
1103
1104     /* we set a 0 umask so that correct file permissions can be
1105        carried across */
1106     orig_umask = (int)umask(0);
1107
1108     parse_arguments(argc, argv);
1109
1110     argc -= optind;
1111     argv += optind;
1112     optind = 0;
1113
1114     signal(SIGCHLD,SIG_IGN);
1115     signal(SIGINT,SIGNAL_CAST sig_int);
1116     signal(SIGPIPE,SIGNAL_CAST sig_int);
1117     signal(SIGHUP,SIGNAL_CAST sig_int);
1118
1119     if (am_daemon) {
1120             return daemon_main();
1121     }
1122
1123     if (dry_run)
1124       verbose = MAX(verbose,1);
1125
1126 #ifndef SUPPORT_LINKS
1127     if (!am_server && preserve_links) {
1128             rprintf(FERROR,"ERROR: symbolic links not supported\n");
1129             exit_cleanup(1);
1130     }
1131 #endif
1132
1133     if (am_server) {
1134             start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
1135     }
1136
1137     if (argc < 2) {
1138       usage(FERROR);
1139       exit_cleanup(1);
1140     }
1141
1142     return start_client(argc, argv);
1143 }
1144