Some daemon security improvements, including the new parameters
[rsync.git] / clientserver.c
1 /*
2  * The socket based protocol for setting up a connection with rsyncd.
3  *
4  * Copyright (C) 1998-2001 Andrew Tridgell <tridge@samba.org>
5  * Copyright (C) 2001-2002 Martin Pool <mbp@samba.org>
6  * Copyright (C) 2002-2007 Wayne Davison
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, visit the http://fsf.org website.
20  */
21
22 #include "rsync.h"
23 #include "ifuncs.h"
24
25 extern int verbose;
26 extern int dry_run;
27 extern int output_motd;
28 extern int list_only;
29 extern int am_sender;
30 extern int am_server;
31 extern int am_daemon;
32 extern int am_root;
33 extern int rsync_port;
34 extern int ignore_errors;
35 extern int kluge_around_eof;
36 extern int daemon_over_rsh;
37 extern int sanitize_paths;
38 extern int numeric_ids;
39 extern int filesfrom_fd;
40 extern int remote_protocol;
41 extern int protocol_version;
42 extern int io_timeout;
43 extern int no_detach;
44 extern int write_batch;
45 extern int default_af_hint;
46 extern int logfile_format_has_i;
47 extern int logfile_format_has_o_or_i;
48 extern mode_t orig_umask;
49 extern char *bind_address;
50 extern char *sockopts;
51 extern char *config_file;
52 extern char *logfile_format;
53 extern char *files_from;
54 extern char *tmpdir;
55 extern struct chmod_mode_struct *chmod_modes;
56 extern struct filter_list_struct server_filter_list;
57 extern char curr_dir[];
58 #ifdef ICONV_OPTION
59 extern char *iconv_opt;
60 extern iconv_t ic_send, ic_recv;
61 #endif
62
63 char *auth_user;
64 int read_only = 0;
65 int module_id = -1;
66 int munge_symlinks = 0;
67 struct chmod_mode_struct *daemon_chmod_modes;
68
69 /* module_dirlen is the length of the module_dir string when in daemon
70  * mode, not chrooted, and the path is not "/"; otherwise 0. */
71 char *module_dir = NULL;
72 unsigned int module_dirlen = 0;
73
74 static int rl_nulls = 0;
75
76 #ifdef HAVE_SIGACTION
77 static struct sigaction sigact;
78 #endif
79
80 /**
81  * Run a client connected to an rsyncd.  The alternative to this
82  * function for remote-shell connections is do_cmd().
83  *
84  * After negotiating which module to use and reading the server's
85  * motd, this hands over to client_run().  Telling the server the
86  * module will cause it to chroot/setuid/etc.
87  *
88  * Instead of doing a transfer, the client may at this stage instead
89  * get a listing of remote modules and exit.
90  *
91  * @return -1 for error in startup, or the result of client_run().
92  * Either way, it eventually gets passed to exit_cleanup().
93  **/
94 int start_socket_client(char *host, int remote_argc, char *remote_argv[],
95                         int argc, char *argv[])
96 {
97         int fd, ret;
98         char *p, *user = NULL;
99
100         /* This is redundant with code in start_inband_exchange(), but this
101          * short-circuits a problem in the client before we open a socket,
102          * and the extra check won't hurt. */
103         if (**remote_argv == '/') {
104                 rprintf(FERROR,
105                         "ERROR: The remote path must start with a module name not a /\n");
106                 return -1;
107         }
108
109         if ((p = strrchr(host, '@')) != NULL) {
110                 user = host;
111                 host = p+1;
112                 *p = '\0';
113         }
114
115         fd = open_socket_out_wrapped(host, rsync_port, bind_address,
116                                      default_af_hint);
117         if (fd == -1)
118                 exit_cleanup(RERR_SOCKETIO);
119
120         set_socket_options(fd, sockopts);
121
122         ret = start_inband_exchange(fd, fd, user, remote_argc, remote_argv);
123
124         return ret ? ret : client_run(fd, fd, -1, argc, argv);
125 }
126
127 static int exchange_protocols(int f_in, int f_out, char *buf, size_t bufsiz, int am_client)
128 {
129         int remote_sub = -1;
130 #if SUBPROTOCOL_VERSION != 0
131         int our_sub = protocol_version < PROTOCOL_VERSION ? 0 : SUBPROTOCOL_VERSION;
132 #else
133         int our_sub = 0;
134 #endif
135         char *motd;
136
137         io_printf(f_out, "@RSYNCD: %d.%d\n", protocol_version, our_sub);
138
139         if (!am_client) {
140                 motd = lp_motd_file();
141                 if (motd && *motd) {
142                         FILE *f = fopen(motd,"r");
143                         while (f && !feof(f)) {
144                                 int len = fread(buf, 1, bufsiz - 1, f);
145                                 if (len > 0)
146                                         write_buf(f_out, buf, len);
147                         }
148                         if (f)
149                                 fclose(f);
150                         write_sbuf(f_out, "\n");
151                 }
152         }
153
154         /* This strips the \n. */
155         if (!read_line_old(f_in, buf, bufsiz)) {
156                 if (am_client)
157                         rprintf(FERROR, "rsync: did not see server greeting\n");
158                 return -1;
159         }
160
161         if (sscanf(buf, "@RSYNCD: %d.%d", &remote_protocol, &remote_sub) < 1) {
162                 if (am_client)
163                         rprintf(FERROR, "rsync: server sent \"%s\" rather than greeting\n", buf);
164                 else
165                         io_printf(f_out, "@ERROR: protocol startup error\n");
166                 return -1;
167         }
168
169         if (remote_sub < 0) {
170                 if (remote_protocol == 30) {
171                         if (am_client)
172                                 rprintf(FERROR, "rsync: server is speaking an incompatible beta of protocol 30\n");
173                         else
174                                 io_printf(f_out, "@ERROR: your client is speaking an incompatible beta of protocol 30\n");
175                         return -1;
176                 }
177                 remote_sub = 0;
178         }
179
180         if (protocol_version > remote_protocol) {
181                 protocol_version = remote_protocol;
182                 if (remote_sub)
183                         protocol_version--;
184         } else if (protocol_version == remote_protocol) {
185                 if (remote_sub != our_sub)
186                         protocol_version--;
187         }
188 #if SUBPROTOCOL_VERSION != 0
189         else if (protocol_version < remote_protocol) {
190                 if (our_sub)
191                         protocol_version--;
192         }
193 #endif
194
195         if (protocol_version >= 30)
196                 rl_nulls = 1;
197
198         return 0;
199 }
200
201 int start_inband_exchange(int f_in, int f_out, const char *user, int argc, char *argv[])
202 {
203         int i, modlen;
204         char line[BIGPATHBUFLEN];
205         char *sargs[MAX_ARGS];
206         int sargc = 0;
207         char *p, *modname;
208
209         assert(argc > 0);
210
211         if (**argv == '/') {
212                 rprintf(FERROR,
213                         "ERROR: The remote path must start with a module name\n");
214                 return -1;
215         }
216
217         if (!(p = strchr(*argv, '/')))
218                 modlen = strlen(*argv);
219         else
220                 modlen = p - *argv;
221
222         if (!(modname = new_array(char, modlen+1+1))) /* room for '/' & '\0' */
223                 out_of_memory("start_inband_exchange");
224         strlcpy(modname, *argv, modlen + 1);
225         modname[modlen] = '/';
226         modname[modlen+1] = '\0';
227
228         if (!user)
229                 user = getenv("USER");
230         if (!user)
231                 user = getenv("LOGNAME");
232
233         if (exchange_protocols(f_in, f_out, line, sizeof line, 1) < 0)
234                 return -1;
235
236         /* set daemon_over_rsh to false since we need to build the
237          * true set of args passed through the rsh/ssh connection;
238          * this is a no-op for direct-socket-connection mode */
239         daemon_over_rsh = 0;
240         server_options(sargs, &sargc);
241
242         if (sargc >= MAX_ARGS - 2)
243                 goto arg_overflow;
244
245         sargs[sargc++] = ".";
246
247         while (argc > 0) {
248                 if (sargc >= MAX_ARGS - 1) {
249                   arg_overflow:
250                         rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n");
251                         exit_cleanup(RERR_SYNTAX);
252                 }
253                 if (strncmp(*argv, modname, modlen) == 0
254                  && argv[0][modlen] == '\0')
255                         sargs[sargc++] = modname; /* we send "modname/" */
256                 else
257                         sargs[sargc++] = *argv;
258                 argv++;
259                 argc--;
260         }
261
262         sargs[sargc] = NULL;
263
264         if (verbose > 1)
265                 print_child_argv("sending daemon args:", sargs);
266
267         io_printf(f_out, "%.*s\n", modlen, modname);
268
269         /* Old servers may just drop the connection here,
270          rather than sending a proper EXIT command.  Yuck. */
271         kluge_around_eof = list_only && protocol_version < 25 ? 1 : 0;
272
273         while (1) {
274                 if (!read_line_old(f_in, line, sizeof line)) {
275                         rprintf(FERROR, "rsync: didn't get server startup line\n");
276                         return -1;
277                 }
278
279                 if (strncmp(line,"@RSYNCD: AUTHREQD ",18) == 0) {
280                         auth_client(f_out, user, line+18);
281                         continue;
282                 }
283
284                 if (strcmp(line,"@RSYNCD: OK") == 0)
285                         break;
286
287                 if (strcmp(line,"@RSYNCD: EXIT") == 0) {
288                         /* This is sent by recent versions of the
289                          * server to terminate the listing of modules.
290                          * We don't want to go on and transfer
291                          * anything; just exit. */
292                         exit(0);
293                 }
294
295                 if (strncmp(line, "@ERROR", 6) == 0) {
296                         rprintf(FERROR, "%s\n", line);
297                         /* This is always fatal; the server will now
298                          * close the socket. */
299                         return -1;
300                 }
301
302                 /* This might be a MOTD line or a module listing, but there is
303                  * no way to differentiate it.  The manpage mentions this. */
304                 if (output_motd)
305                         rprintf(FINFO, "%s\n", line);
306         }
307         kluge_around_eof = 0;
308
309         if (rl_nulls) {
310                 for (i = 0; i < sargc; i++) {
311                         write_sbuf(f_out, sargs[i]);
312                         write_byte(f_out, 0);
313                 }
314                 write_byte(f_out, 0);
315         } else {
316                 for (i = 0; i < sargc; i++)
317                         io_printf(f_out, "%s\n", sargs[i]);
318                 write_sbuf(f_out, "\n");
319         }
320
321         if (protocol_version < 23) {
322                 if (protocol_version == 22 || !am_sender)
323                         io_start_multiplex_in();
324         }
325
326         free(modname);
327
328         return 0;
329 }
330
331 static char *finish_pre_exec(pid_t pid, int fd, char *request,
332                              int argc, char *argv[])
333 {
334         int j, status = -1;
335
336         if (!request)
337                 request = "(NONE)";
338
339         write_buf(fd, request, strlen(request)+1);
340         for (j = 0; j < argc; j++)
341                 write_buf(fd, argv[j], strlen(argv[j])+1);
342         write_byte(fd, 0);
343
344         close(fd);
345
346         if (wait_process(pid, &status, 0) < 0
347          || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
348                 char *e;
349                 if (asprintf(&e, "pre-xfer exec returned failure (%d)%s%s\n",
350                              status, status < 0 ? ": " : "",
351                              status < 0 ? strerror(errno) : "") < 0)
352                         out_of_memory("finish_pre_exec");
353                 return e;
354         }
355         return NULL;
356 }
357
358 static int read_arg_from_pipe(int fd, char *buf, int limit)
359 {
360         char *bp = buf, *eob = buf + limit - 1;
361
362         while (1) {
363             int got = read(fd, bp, 1);
364             if (got != 1) {
365                 if (got < 0 && errno == EINTR)
366                         continue;
367                 return -1;
368             }
369             if (*bp == '\0')
370                 break;
371             if (bp < eob)
372                 bp++;
373         }
374         *bp = '\0';
375
376         return bp - buf;
377 }
378
379 static int rsync_module(int f_in, int f_out, int i, char *addr, char *host)
380 {
381         int argc, opt_cnt;
382         char **argv;
383         char line[BIGPATHBUFLEN];
384         uid_t uid = (uid_t)-2;  /* canonically "nobody" */
385         gid_t gid = (gid_t)-2;
386         char *p, *err_msg = NULL;
387         char *name = lp_name(i);
388         int use_chroot = lp_use_chroot(i);
389         int ret, pre_exec_fd = -1;
390         pid_t pre_exec_pid = 0;
391         char *request = NULL;
392
393 #ifdef ICONV_CONST
394         iconv_opt = lp_charset(i);
395         if (*iconv_opt)
396                 setup_iconv();
397         iconv_opt = NULL;
398 #endif
399
400         if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) {
401                 rprintf(FLOG, "rsync denied on module %s from %s (%s)\n",
402                         name, host, addr);
403                 if (!lp_list(i))
404                         io_printf(f_out, "@ERROR: Unknown module '%s'\n", name);
405                 else {
406                         io_printf(f_out,
407                                   "@ERROR: access denied to %s from %s (%s)\n",
408                                   name, host, addr);
409                 }
410                 return -1;
411         }
412
413         if (am_daemon && am_server) {
414                 rprintf(FLOG, "rsync allowed access on module %s from %s (%s)\n",
415                         name, host, addr);
416         }
417
418         if (!claim_connection(lp_lock_file(i), lp_max_connections(i))) {
419                 if (errno) {
420                         rsyserr(FLOG, errno, "failed to open lock file %s",
421                                 lp_lock_file(i));
422                         io_printf(f_out, "@ERROR: failed to open lock file\n");
423                 } else {
424                         rprintf(FLOG, "max connections (%d) reached\n",
425                                 lp_max_connections(i));
426                         io_printf(f_out, "@ERROR: max connections (%d) reached -- try again later\n",
427                                 lp_max_connections(i));
428                 }
429                 return -1;
430         }
431
432         auth_user = auth_server(f_in, f_out, i, host, addr, "@RSYNCD: AUTHREQD ");
433
434         if (!auth_user) {
435                 io_printf(f_out, "@ERROR: auth failed on module %s\n", name);
436                 return -1;
437         }
438
439         module_id = i;
440
441         if (lp_read_only(i))
442                 read_only = 1;
443
444         if (lp_transfer_logging(i) && !logfile_format)
445                 logfile_format = lp_log_format(i);
446         if (log_format_has(logfile_format, 'i'))
447                 logfile_format_has_i = 1;
448         if (logfile_format_has_i || log_format_has(logfile_format, 'o'))
449                 logfile_format_has_o_or_i = 1;
450
451         am_root = (MY_UID() == 0);
452
453         if (am_root) {
454                 p = lp_uid(i);
455                 if (!name_to_uid(p, &uid)) {
456                         if (!isDigit(p)) {
457                                 rprintf(FLOG, "Invalid uid %s\n", p);
458                                 io_printf(f_out, "@ERROR: invalid uid %s\n", p);
459                                 return -1;
460                         }
461                         uid = atoi(p);
462                 }
463
464                 p = lp_gid(i);
465                 if (!name_to_gid(p, &gid)) {
466                         if (!isDigit(p)) {
467                                 rprintf(FLOG, "Invalid gid %s\n", p);
468                                 io_printf(f_out, "@ERROR: invalid gid %s\n", p);
469                                 return -1;
470                         }
471                         gid = atoi(p);
472                 }
473         }
474
475         /* TODO: If we're not root, but the configuration requests
476          * that we change to some uid other than the current one, then
477          * log a warning. */
478
479         /* TODO: Perhaps take a list of gids, and make them into the
480          * supplementary groups. */
481
482         /* We do a push_dir() without actually calling chdir() in order
483          * to make sure that the module's path is absolute.  After this
484          * check, module_dir will be set to an absolute path. */
485         module_dir = lp_path(i);
486         strlcpy(line, curr_dir, sizeof line);
487         if (!push_dir(module_dir, 1))
488                 goto chdir_failed;
489         if (strcmp(curr_dir, module_dir) != 0)
490                 module_dir = strdup(curr_dir);
491         push_dir(line, 1); /* Restore curr_dir. */
492
493         if (use_chroot || (module_dirlen = strlen(module_dir)) == 1) {
494                 module_dirlen = 0;
495                 set_filter_dir("/", 1);
496         } else
497                 set_filter_dir(module_dir, module_dirlen);
498
499         p = lp_filter(i);
500         parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
501                    XFLG_ABS_IF_SLASH);
502
503         p = lp_include_from(i);
504         parse_filter_file(&server_filter_list, p, MATCHFLG_INCLUDE,
505             XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
506
507         p = lp_include(i);
508         parse_rule(&server_filter_list, p,
509                    MATCHFLG_INCLUDE | MATCHFLG_WORD_SPLIT,
510                    XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES);
511
512         p = lp_exclude_from(i);
513         parse_filter_file(&server_filter_list, p, 0,
514             XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES | XFLG_FATAL_ERRORS);
515
516         p = lp_exclude(i);
517         parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT,
518                    XFLG_ABS_IF_SLASH | XFLG_OLD_PREFIXES);
519
520         log_init(1);
521
522 #ifdef HAVE_PUTENV
523         if (*lp_prexfer_exec(i) || *lp_postxfer_exec(i)) {
524                 char *modname, *modpath, *hostaddr, *hostname, *username;
525                 int status;
526                 if (asprintf(&modname, "RSYNC_MODULE_NAME=%s", name) < 0
527                  || asprintf(&modpath, "RSYNC_MODULE_PATH=%s", module_dir) < 0
528                  || asprintf(&hostaddr, "RSYNC_HOST_ADDR=%s", addr) < 0
529                  || asprintf(&hostname, "RSYNC_HOST_NAME=%s", host) < 0
530                  || asprintf(&username, "RSYNC_USER_NAME=%s", auth_user) < 0)
531                         out_of_memory("rsync_module");
532                 putenv(modname);
533                 putenv(modpath);
534                 putenv(hostaddr);
535                 putenv(hostname);
536                 putenv(username);
537                 umask(orig_umask);
538                 /* For post-xfer exec, fork a new process to run the rsync
539                  * daemon while this process waits for the exit status and
540                  * runs the indicated command at that point. */
541                 if (*lp_postxfer_exec(i)) {
542                         pid_t pid = fork();
543                         if (pid < 0) {
544                                 rsyserr(FLOG, errno, "fork failed");
545                                 io_printf(f_out, "@ERROR: fork failed\n");
546                                 return -1;
547                         }
548                         if (pid) {
549                                 if (asprintf(&p, "RSYNC_PID=%ld", (long)pid) > 0)
550                                         putenv(p);
551                                 if (wait_process(pid, &status, 0) < 0)
552                                         status = -1;
553                                 if (asprintf(&p, "RSYNC_RAW_STATUS=%d", status) > 0)
554                                         putenv(p);
555                                 if (WIFEXITED(status))
556                                         status = WEXITSTATUS(status);
557                                 else
558                                         status = -1;
559                                 if (asprintf(&p, "RSYNC_EXIT_STATUS=%d", status) > 0)
560                                         putenv(p);
561                                 system(lp_postxfer_exec(i));
562                                 _exit(status);
563                         }
564                 }
565                 /* For pre-xfer exec, fork a child process to run the indicated
566                  * command, though it first waits for the parent process to
567                  * send us the user's request via a pipe. */
568                 if (*lp_prexfer_exec(i)) {
569                         int fds[2];
570                         if (asprintf(&p, "RSYNC_PID=%ld", (long)getpid()) > 0)
571                                 putenv(p);
572                         if (pipe(fds) < 0 || (pre_exec_pid = fork()) < 0) {
573                                 rsyserr(FLOG, errno, "pre-xfer exec preparation failed");
574                                 io_printf(f_out, "@ERROR: pre-xfer exec preparation failed\n");
575                                 return -1;
576                         }
577                         if (pre_exec_pid == 0) {
578                                 char buf[BIGPATHBUFLEN];
579                                 int j, len;
580                                 close(fds[1]);
581                                 set_blocking(fds[0]);
582                                 len = read_arg_from_pipe(fds[0], buf, BIGPATHBUFLEN);
583                                 if (len <= 0)
584                                         _exit(1);
585                                 if (asprintf(&p, "RSYNC_REQUEST=%s", buf) > 0)
586                                         putenv(p);
587                                 for (j = 0; ; j++) {
588                                         len = read_arg_from_pipe(fds[0], buf,
589                                                                  BIGPATHBUFLEN);
590                                         if (len <= 0) {
591                                                 if (!len)
592                                                         break;
593                                                 _exit(1);
594                                         }
595                                         if (asprintf(&p, "RSYNC_ARG%d=%s", j, buf) > 0)
596                                                 putenv(p);
597                                 }
598                                 close(fds[0]);
599                                 close(STDIN_FILENO);
600                                 close(STDOUT_FILENO);
601                                 status = system(lp_prexfer_exec(i));
602                                 if (!WIFEXITED(status))
603                                         _exit(1);
604                                 _exit(WEXITSTATUS(status));
605                         }
606                         close(fds[0]);
607                         set_blocking(fds[1]);
608                         pre_exec_fd = fds[1];
609                 }
610                 umask(0);
611         }
612 #endif
613
614         if (use_chroot) {
615                 /*
616                  * XXX: The 'use chroot' flag is a fairly reliable
617                  * source of confusion, because it fails under two
618                  * important circumstances: running as non-root,
619                  * running on Win32 (or possibly others).  On the
620                  * other hand, if you are running as root, then it
621                  * might be better to always use chroot.
622                  *
623                  * So, perhaps if we can't chroot we should just issue
624                  * a warning, unless a "require chroot" flag is set,
625                  * in which case we fail.
626                  */
627                 if (chroot(module_dir)) {
628                         rsyserr(FLOG, errno, "chroot %s failed", module_dir);
629                         io_printf(f_out, "@ERROR: chroot failed\n");
630                         return -1;
631                 }
632                 if (!push_dir("/", 0))
633                         goto chdir_failed;
634         } else {
635                 if (!push_dir(module_dir, 0)) {
636                   chdir_failed:
637                         rsyserr(FLOG, errno, "chdir %s failed\n", module_dir);
638                         io_printf(f_out, "@ERROR: chdir failed\n");
639                         return -1;
640                 }
641                 sanitize_paths = 1;
642         }
643
644         if ((munge_symlinks = lp_munge_symlinks(i)) < 0)
645                 munge_symlinks = !use_chroot;
646         if (munge_symlinks) {
647                 STRUCT_STAT st;
648                 if (stat(SYMLINK_PREFIX, &st) == 0 && S_ISDIR(st.st_mode)) {
649                         rprintf(FLOG, "Symlink munging is unsupported when a %s directory exists.\n",
650                                 SYMLINK_PREFIX);
651                         io_printf(f_out, "@ERROR: daemon security issue -- contact admin\n", name);
652                         exit_cleanup(RERR_UNSUPPORTED);
653                 }
654         }
655
656         if (am_root) {
657                 /* XXXX: You could argue that if the daemon is started
658                  * by a non-root user and they explicitly specify a
659                  * gid, then we should try to change to that gid --
660                  * this could be possible if it's already in their
661                  * supplementary groups. */
662
663                 /* TODO: Perhaps we need to document that if rsyncd is
664                  * started by somebody other than root it will inherit
665                  * all their supplementary groups. */
666
667                 if (setgid(gid)) {
668                         rsyserr(FLOG, errno, "setgid %d failed", (int)gid);
669                         io_printf(f_out, "@ERROR: setgid failed\n");
670                         return -1;
671                 }
672 #ifdef HAVE_SETGROUPS
673                 /* Get rid of any supplementary groups this process
674                  * might have inheristed. */
675                 if (setgroups(1, &gid)) {
676                         rsyserr(FLOG, errno, "setgroups failed");
677                         io_printf(f_out, "@ERROR: setgroups failed\n");
678                         return -1;
679                 }
680 #endif
681
682                 if (setuid(uid)) {
683                         rsyserr(FLOG, errno, "setuid %d failed", (int)uid);
684                         io_printf(f_out, "@ERROR: setuid failed\n");
685                         return -1;
686                 }
687
688                 am_root = (MY_UID() == 0);
689         }
690
691         if (lp_temp_dir(i) && *lp_temp_dir(i)) {
692                 tmpdir = lp_temp_dir(i);
693                 if (strlen(tmpdir) >= MAXPATHLEN - 10) {
694                         rprintf(FLOG,
695                                 "the 'temp dir' value for %s is WAY too long -- ignoring.\n",
696                                 name);
697                         tmpdir = NULL;
698                 }
699         }
700
701         io_printf(f_out, "@RSYNCD: OK\n");
702
703         opt_cnt = read_args(f_in, name, line, sizeof line, rl_nulls, &argv, &argc, &request);
704
705         if (pre_exec_pid) {
706                 err_msg = finish_pre_exec(pre_exec_pid, pre_exec_fd, request,
707                                           opt_cnt, argv);
708         }
709
710         verbose = 0; /* future verbosity is controlled by client options */
711         ret = parse_arguments(&argc, (const char ***) &argv, 0);
712         am_server = 1; /* Don't let someone try to be tricky. */
713         if (lp_ignore_errors(module_id))
714                 ignore_errors = 1;
715         if (write_batch < 0)
716                 dry_run = 1;
717
718         if (lp_fake_super(i))
719                 am_root = -1;
720         else if (am_root < 0) /* Treat --fake-super from client as --super. */
721                 am_root = 2;
722
723         if (filesfrom_fd == 0)
724                 filesfrom_fd = f_in;
725
726         if (request) {
727                 if (*auth_user) {
728                         rprintf(FLOG, "rsync %s %s from %s@%s (%s)\n",
729                                 am_sender ? "on" : "to",
730                                 request, auth_user, host, addr);
731                 } else {
732                         rprintf(FLOG, "rsync %s %s from %s (%s)\n",
733                                 am_sender ? "on" : "to",
734                                 request, host, addr);
735                 }
736                 free(request);
737         }
738
739 #ifndef DEBUG
740         /* don't allow the logs to be flooded too fast */
741         if (verbose > lp_max_verbosity(i))
742                 verbose = lp_max_verbosity(i);
743 #endif
744
745         if (protocol_version < 23
746             && (protocol_version == 22 || am_sender))
747                 io_start_multiplex_out();
748         else if (!ret || err_msg) {
749                 /* We have to get I/O multiplexing started so that we can
750                  * get the error back to the client.  This means getting
751                  * the protocol setup finished first in later versions. */
752                 setup_protocol(f_out, f_in);
753                 if (!am_sender) {
754                         /* Since we failed in our option parsing, we may not
755                          * have finished parsing that the client sent us a
756                          * --files-from option, so look for it manually.
757                          * Without this, the socket would be in the wrong
758                          * state for the upcoming error message. */
759                         if (!files_from) {
760                                 int i;
761                                 for (i = 0; i < argc; i++) {
762                                         if (strncmp(argv[i], "--files-from", 12) == 0) {
763                                                 files_from = "";
764                                                 break;
765                                         }
766                                 }
767                         }
768                         if (files_from)
769                                 write_byte(f_out, 0);
770                 }
771                 io_start_multiplex_out();
772         }
773
774         if (!ret || err_msg) {
775                 if (err_msg)
776                         rwrite(FERROR, err_msg, strlen(err_msg), 0);
777                 else
778                         option_error();
779                 msleep(400);
780                 exit_cleanup(RERR_UNSUPPORTED);
781         }
782
783         if (!iconv_opt) {
784                 if (ic_send != (iconv_t)-1) {
785                         iconv_close(ic_send);
786                         ic_send = (iconv_t)-1;
787                 }
788                 if (ic_recv != (iconv_t)-1) {
789                         iconv_close(ic_recv);
790                         ic_recv = (iconv_t)-1;
791                 }
792         }
793
794         if (!numeric_ids
795          && (use_chroot ? lp_numeric_ids(i) != False : lp_numeric_ids(i) == True))
796                 numeric_ids = -1; /* Set --numeric-ids w/o breaking protocol. */
797
798         if (lp_timeout(i) && lp_timeout(i) > io_timeout)
799                 set_io_timeout(lp_timeout(i));
800
801         /* If we have some incoming/outgoing chmod changes, append them to
802          * any user-specified changes (making our changes have priority).
803          * We also get a pointer to just our changes so that a receiver
804          * process can use them separately if --perms wasn't specified. */
805         if (am_sender)
806                 p = lp_outgoing_chmod(i);
807         else
808                 p = lp_incoming_chmod(i);
809         if (*p && !(daemon_chmod_modes = parse_chmod(p, &chmod_modes))) {
810                 rprintf(FLOG, "Invalid \"%sing chmod\" directive: %s\n",
811                         am_sender ? "outgo" : "incom", p);
812         }
813
814         start_server(f_in, f_out, argc, argv);
815
816         return 0;
817 }
818
819 /* send a list of available modules to the client. Don't list those
820    with "list = False". */
821 static void send_listing(int fd)
822 {
823         int n = lp_numservices();
824         int i;
825
826         for (i = 0; i < n; i++) {
827                 if (lp_list(i))
828                         io_printf(fd, "%-15s\t%s\n", lp_name(i), lp_comment(i));
829         }
830
831         if (protocol_version >= 25)
832                 io_printf(fd,"@RSYNCD: EXIT\n");
833 }
834
835 /* this is called when a connection is established to a client
836    and we want to start talking. The setup of the system is done from
837    here */
838 int start_daemon(int f_in, int f_out)
839 {
840         char line[1024];
841         char *addr, *host;
842         int i;
843
844         io_set_sock_fds(f_in, f_out);
845
846         /* We must load the config file before calling any function that
847          * might cause log-file output to occur.  This ensures that the
848          * "log file" param gets honored for the 2 non-forked use-cases
849          * (when rsync is run by init and run by a remote shell). */
850         if (!lp_load(config_file, 0))
851                 exit_cleanup(RERR_SYNTAX);
852
853         addr = client_addr(f_in);
854         host = client_name(f_in);
855         rprintf(FLOG, "connect from %s (%s)\n", host, addr);
856
857         if (!am_server) {
858                 set_socket_options(f_in, "SO_KEEPALIVE");
859                 if (sockopts)
860                         set_socket_options(f_in, sockopts);
861                 else
862                         set_socket_options(f_in, lp_socket_options());
863                 set_nonblocking(f_in);
864         }
865
866         if (exchange_protocols(f_in, f_out, line, sizeof line, 0) < 0)
867                 return -1;
868
869         line[0] = 0;
870         if (!read_line_old(f_in, line, sizeof line))
871                 return -1;
872
873         if (!*line || strcmp(line, "#list") == 0) {
874                 rprintf(FLOG, "module-list request from %s (%s)\n",
875                         host, addr);
876                 send_listing(f_out);
877                 return -1;
878         }
879
880         if (*line == '#') {
881                 /* it's some sort of command that I don't understand */
882                 io_printf(f_out, "@ERROR: Unknown command '%s'\n", line);
883                 return -1;
884         }
885
886         if ((i = lp_number(line)) < 0) {
887                 rprintf(FLOG, "unknown module '%s' tried from %s (%s)\n",
888                         line, host, addr);
889                 io_printf(f_out, "@ERROR: Unknown module '%s'\n", line);
890                 return -1;
891         }
892
893 #ifdef HAVE_SIGACTION
894         sigact.sa_flags = SA_NOCLDSTOP;
895 #endif
896         SIGACTION(SIGCHLD, remember_children);
897
898         return rsync_module(f_in, f_out, i, addr, host);
899 }
900
901 static void create_pid_file(void)
902 {
903         char *pid_file = lp_pid_file();
904         char pidbuf[16];
905         pid_t pid = getpid();
906         int fd;
907
908         if (!pid_file || !*pid_file)
909                 return;
910
911         cleanup_set_pid(pid);
912         if ((fd = do_open(pid_file, O_WRONLY|O_CREAT|O_EXCL, 0666 & ~orig_umask)) == -1) {
913                 cleanup_set_pid(0);
914                 fprintf(stderr, "failed to create pid file %s: %s\n", pid_file, strerror(errno));
915                 rsyserr(FLOG, errno, "failed to create pid file %s", pid_file);
916                 exit_cleanup(RERR_FILEIO);
917         }
918         snprintf(pidbuf, sizeof pidbuf, "%ld\n", (long)pid);
919         write(fd, pidbuf, strlen(pidbuf));
920         close(fd);
921 }
922
923 /* Become a daemon, discarding the controlling terminal. */
924 static void become_daemon(void)
925 {
926         int i;
927         pid_t pid = fork();
928
929         if (pid) {
930                 if (pid < 0) {
931                         fprintf(stderr, "failed to fork: %s\n", strerror(errno));
932                         exit_cleanup(RERR_FILEIO);
933                 }
934                 _exit(0);
935         }
936
937         create_pid_file();
938
939         /* detach from the terminal */
940 #ifdef HAVE_SETSID
941         setsid();
942 #elif defined TIOCNOTTY
943         i = open("/dev/tty", O_RDWR);
944         if (i >= 0) {
945                 ioctl(i, (int)TIOCNOTTY, (char *)0);
946                 close(i);
947         }
948 #endif
949         /* make sure that stdin, stdout an stderr don't stuff things
950          * up (library functions, for example) */
951         for (i = 0; i < 3; i++) {
952                 close(i);
953                 open("/dev/null", O_RDWR);
954         }
955 }
956
957 int daemon_main(void)
958 {
959         if (!config_file) {
960                 if (am_server && am_root <= 0)
961                         config_file = RSYNCD_USERCONF;
962                 else
963                         config_file = RSYNCD_SYSCONF;
964         }
965
966         if (is_a_socket(STDIN_FILENO)) {
967                 int i;
968
969                 /* we are running via inetd - close off stdout and
970                  * stderr so that library functions (and getopt) don't
971                  * try to use them. Redirect them to /dev/null */
972                 for (i = 1; i < 3; i++) {
973                         close(i);
974                         open("/dev/null", O_RDWR);
975                 }
976
977                 return start_daemon(STDIN_FILENO, STDIN_FILENO);
978         }
979
980         if (!lp_load(config_file, 1)) {
981                 fprintf(stderr, "Failed to parse config file: %s\n", config_file);
982                 exit_cleanup(RERR_SYNTAX);
983         }
984
985         if (no_detach)
986                 create_pid_file();
987         else
988                 become_daemon();
989
990         if (rsync_port == 0 && (rsync_port = lp_rsync_port()) == 0)
991                 rsync_port = RSYNC_PORT;
992         if (bind_address == NULL && *lp_bind_address())
993                 bind_address = lp_bind_address();
994
995         log_init(0);
996
997         rprintf(FLOG, "rsyncd version %s starting, listening on port %d\n",
998                 RSYNC_VERSION, rsync_port);
999         /* TODO: If listening on a particular address, then show that
1000          * address too.  In fact, why not just do inet_ntop on the
1001          * local address??? */
1002
1003         start_accept_loop(rsync_port, start_daemon);
1004         return -1;
1005 }