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