039b05dabae4628d25e15345d915f743abb935a4
[rsync.git] / 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] == ':') { /* double colon */
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                 } else if (p[1] == ':') {
720                         *p = 0;
721                         return start_socket_client(argv[argc-1], p+2, argc-1, argv);
722                 }
723
724                 if (argc < 2) {
725                         usage(FERROR);
726                         exit_cleanup(RERR_SYNTAX);
727                 }
728                 
729                 if (local_server) {
730                         shell_machine = NULL;
731                         shell_path = argv[argc-1];
732                 } else {
733                         *p = 0;
734                         shell_machine = argv[argc-1];
735                         shell_path = p+1;
736                 }
737                 argc--;
738         }
739         } else {
740             am_sender = 1;
741             local_server = 1;
742             shell_path = argv[argc-1];
743         }
744
745         if (shell_machine) {
746                 p = strchr(shell_machine,'@');
747                 if (p) {
748                         *p = 0;
749                         shell_user = shell_machine;
750                         shell_machine = p+1;
751                 }
752         }
753
754         if (verbose > 3) {
755                 rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
756                         shell_cmd?shell_cmd:"",
757                         shell_machine?shell_machine:"",
758                         shell_user?shell_user:"",
759                         shell_path?shell_path:"");
760         }
761         
762         if (!am_sender && argc > 1) {
763                 usage(FERROR);
764                 exit_cleanup(RERR_SYNTAX);
765         }
766
767         if (argc == 0 && !am_sender) {
768                 extern int list_only;
769                 list_only = 1;
770         }
771         
772         pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,&f_in,&f_out);
773         
774         ret = client_run(f_in, f_out, pid, argc, argv);
775
776         fflush(stdout);
777         fflush(stderr);
778
779         return ret;
780 }
781
782
783 static RETSIGTYPE sigusr1_handler(int UNUSED(val)) {
784         exit_cleanup(RERR_SIGNAL);
785 }
786
787 static RETSIGTYPE sigusr2_handler(int UNUSED(val)) {
788         extern int log_got_error;
789         if (log_got_error) _exit(RERR_PARTIAL);
790         _exit(0);
791 }
792
793 static RETSIGTYPE sigchld_handler(int UNUSED(val)) {
794 #ifdef WNOHANG
795         while (waitpid(-1, NULL, WNOHANG) > 0) ;
796 #endif
797 }
798
799 int main(int argc,char *argv[])
800 {       
801         extern int am_root;
802         extern int orig_umask;
803         extern int dry_run;
804         extern int am_daemon;
805         extern int am_server;
806         int ret;
807         extern int write_batch;
808         int orig_argc;
809         char **orig_argv;
810
811         orig_argc = argc;
812         orig_argv = argv;
813
814         signal(SIGUSR1, sigusr1_handler);
815         signal(SIGUSR2, sigusr2_handler);
816         signal(SIGCHLD, sigchld_handler);
817
818         starttime = time(NULL);
819         am_root = (getuid() == 0);
820
821         memset(&stats, 0, sizeof(stats));
822
823         if (argc < 2) {
824                 usage(FERROR);
825                 exit_cleanup(RERR_SYNTAX);
826         }
827
828         /* we set a 0 umask so that correct file permissions can be
829            carried across */
830         orig_umask = (int)umask(0);
831
832         if (!parse_arguments(&argc, (const char ***) &argv, 1)) {
833                 /* FIXME: We ought to call the same error-handling
834                  * code here, rather than relying on getopt. */
835                 option_error();
836                 exit_cleanup(RERR_SYNTAX);
837         }
838
839         signal(SIGINT,SIGNAL_CAST sig_int);
840         signal(SIGHUP,SIGNAL_CAST sig_int);
841         signal(SIGTERM,SIGNAL_CAST sig_int);
842
843         /* Ignore SIGPIPE; we consistently check error codes and will
844          * see the EPIPE. */
845         signal(SIGPIPE, SIG_IGN);
846
847         /* Initialize push_dir here because on some old systems getcwd
848            (implemented by forking "pwd" and reading its output) doesn't
849            work when there are other child processes.  Also, on all systems
850            that implement getcwd that way "pwd" can't be found after chroot. */
851         push_dir(NULL,0);
852
853         if (write_batch && !am_server) {
854             write_batch_argvs_file(orig_argc, orig_argv);
855         }
856
857         if (am_daemon) {
858                 return daemon_main();
859         }
860
861         if (argc < 1) {
862                 usage(FERROR);
863                 exit_cleanup(RERR_SYNTAX);
864         }
865
866         if (dry_run)
867                 verbose = MAX(verbose,1);
868
869 #ifndef SUPPORT_LINKS
870         if (!am_server && preserve_links) {
871                 rprintf(FERROR,"ERROR: symbolic links not supported\n");
872                 exit_cleanup(RERR_UNSUPPORTED);
873         }
874 #endif
875
876         if (am_server) {
877                 set_nonblocking(STDIN_FILENO);
878                 set_nonblocking(STDOUT_FILENO);
879                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
880         }
881
882         ret = start_client(argc, argv);
883         if (ret == -1) 
884                 exit_cleanup(RERR_STARTCLIENT);
885         else
886                 exit_cleanup(ret);
887
888         exit(ret);
889         /* NOTREACHED */
890 }