X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/3162ea6f672b0f861319d634c3c0e1615124dd91..cbbd8e2e8bf72aa46c84c7de43e19da40f040fa7:/clientserver.c diff --git a/clientserver.c b/clientserver.c index 0f924515..6bcbc81e 100644 --- a/clientserver.c +++ b/clientserver.c @@ -3,11 +3,11 @@ * * Copyright (C) 1998-2001 Andrew Tridgell * Copyright (C) 2001-2002 Martin Pool - * Copyright (C) 2002, 2003, 2004, 2005, 2006 Wayne Davison + * Copyright (C) 2002-2008 Wayne Davison * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, @@ -16,14 +16,14 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. + * with this program; if not, visit the http://fsf.org website. */ #include "rsync.h" +#include "ifuncs.h" extern int verbose; -extern int quiet; +extern int dry_run; extern int output_motd; extern int list_only; extern int am_sender; @@ -32,14 +32,17 @@ extern int am_daemon; extern int am_root; extern int rsync_port; extern int ignore_errors; +extern int preserve_xattrs; extern int kluge_around_eof; extern int daemon_over_rsh; extern int sanitize_paths; +extern int numeric_ids; extern int filesfrom_fd; extern int remote_protocol; extern int protocol_version; extern int io_timeout; extern int no_detach; +extern int write_batch; extern int default_af_hint; extern int logfile_format_has_i; extern int logfile_format_has_o_or_i; @@ -52,15 +55,26 @@ extern char *files_from; extern char *tmpdir; extern struct chmod_mode_struct *chmod_modes; extern struct filter_list_struct server_filter_list; +extern char curr_dir[]; +#ifdef ICONV_OPTION +extern char *iconv_opt; +extern iconv_t ic_send, ic_recv; +#endif char *auth_user; int read_only = 0; int module_id = -1; +int munge_symlinks = 0; struct chmod_mode_struct *daemon_chmod_modes; -/* Length of lp_path() string when in daemon mode & not chrooted, else 0. */ +/* module_dirlen is the length of the module_dir string when in daemon + * mode and module_dir is not "/"; otherwise 0. (Note that a chroot- + * enabled module can have a non-"/" module_dir these days.) */ +char *module_dir = NULL; unsigned int module_dirlen = 0; +static int rl_nulls = 0; + #ifdef HAVE_SIGACTION static struct sigaction sigact; #endif @@ -79,7 +93,8 @@ static struct sigaction sigact; * @return -1 for error in startup, or the result of client_run(). * Either way, it eventually gets passed to exit_cleanup(). **/ -int start_socket_client(char *host, char *path, int argc, char *argv[]) +int start_socket_client(char *host, int remote_argc, char *remote_argv[], + int argc, char *argv[]) { int fd, ret; char *p, *user = NULL; @@ -87,7 +102,7 @@ int start_socket_client(char *host, char *path, int argc, char *argv[]) /* This is redundant with code in start_inband_exchange(), but this * short-circuits a problem in the client before we open a socket, * and the extra check won't hurt. */ - if (*path == '/') { + if (**remote_argv == '/') { rprintf(FERROR, "ERROR: The remote path must start with a module name not a /\n"); return -1; @@ -106,52 +121,123 @@ int start_socket_client(char *host, char *path, int argc, char *argv[]) set_socket_options(fd, sockopts); - ret = start_inband_exchange(user, path, fd, fd, argc); +#ifdef ICONV_CONST + setup_iconv(); +#endif + + ret = start_inband_exchange(fd, fd, user, remote_argc, remote_argv); return ret ? ret : client_run(fd, fd, -1, argc, argv); } -int start_inband_exchange(const char *user, char *path, int f_in, int f_out, - int argc) +static int exchange_protocols(int f_in, int f_out, char *buf, size_t bufsiz, int am_client) { - int i; + int remote_sub = -1; +#if SUBPROTOCOL_VERSION != 0 + int our_sub = protocol_version < PROTOCOL_VERSION ? 0 : SUBPROTOCOL_VERSION; +#else + int our_sub = 0; +#endif + char *motd; + + io_printf(f_out, "@RSYNCD: %d.%d\n", protocol_version, our_sub); + + if (!am_client) { + motd = lp_motd_file(); + if (motd && *motd) { + FILE *f = fopen(motd,"r"); + while (f && !feof(f)) { + int len = fread(buf, 1, bufsiz - 1, f); + if (len > 0) + write_buf(f_out, buf, len); + } + if (f) + fclose(f); + write_sbuf(f_out, "\n"); + } + } + + /* This strips the \n. */ + if (!read_line_old(f_in, buf, bufsiz)) { + if (am_client) + rprintf(FERROR, "rsync: did not see server greeting\n"); + return -1; + } + + if (sscanf(buf, "@RSYNCD: %d.%d", &remote_protocol, &remote_sub) < 1) { + if (am_client) + rprintf(FERROR, "rsync: server sent \"%s\" rather than greeting\n", buf); + else + io_printf(f_out, "@ERROR: protocol startup error\n"); + return -1; + } + + if (remote_sub < 0) { + if (remote_protocol == 30) { + if (am_client) + rprintf(FERROR, "rsync: server is speaking an incompatible beta of protocol 30\n"); + else + io_printf(f_out, "@ERROR: your client is speaking an incompatible beta of protocol 30\n"); + return -1; + } + remote_sub = 0; + } + + if (protocol_version > remote_protocol) { + protocol_version = remote_protocol; + if (remote_sub) + protocol_version--; + } else if (protocol_version == remote_protocol) { + if (remote_sub != our_sub) + protocol_version--; + } +#if SUBPROTOCOL_VERSION != 0 + else if (protocol_version < remote_protocol) { + if (our_sub) + protocol_version--; + } +#endif + + if (protocol_version >= 30) + rl_nulls = 1; + + return 0; +} + +int start_inband_exchange(int f_in, int f_out, const char *user, int argc, char *argv[]) +{ + int i, modlen; + char line[BIGPATHBUFLEN]; char *sargs[MAX_ARGS]; int sargc = 0; - char line[BIGPATHBUFLEN]; - char *p; + char *p, *modname; - if (argc == 0 && !am_sender) - list_only |= 1; + assert(argc > 0); - if (*path == '/') { + if (**argv == '/') { rprintf(FERROR, "ERROR: The remote path must start with a module name\n"); return -1; } + if (!(p = strchr(*argv, '/'))) + modlen = strlen(*argv); + else + modlen = p - *argv; + + if (!(modname = new_array(char, modlen+1+1))) /* room for '/' & '\0' */ + out_of_memory("start_inband_exchange"); + strlcpy(modname, *argv, modlen + 1); + modname[modlen] = '/'; + modname[modlen+1] = '\0'; + if (!user) user = getenv("USER"); if (!user) user = getenv("LOGNAME"); - io_printf(f_out, "@RSYNCD: %d\n", protocol_version); - - if (!read_line(f_in, line, sizeof line - 1)) { - rprintf(FERROR, "rsync: did not see server greeting\n"); + if (exchange_protocols(f_in, f_out, line, sizeof line, 1) < 0) return -1; - } - - if (sscanf(line,"@RSYNCD: %d", &remote_protocol) != 1) { - /* note that read_line strips of \n or \r */ - rprintf(FERROR, "rsync: server sent \"%s\" rather than greeting\n", - line); - return -1; - } - if (protocol_version > remote_protocol) - protocol_version = remote_protocol; - - if (list_only && protocol_version >= 29) - list_only |= 2; /* set daemon_over_rsh to false since we need to build the * true set of args passed through the rsh/ssh connection; @@ -159,27 +245,39 @@ int start_inband_exchange(const char *user, char *path, int f_in, int f_out, daemon_over_rsh = 0; server_options(sargs, &sargc); + if (sargc >= MAX_ARGS - 2) + goto arg_overflow; + sargs[sargc++] = "."; - if (path && *path) - sargs[sargc++] = path; + while (argc > 0) { + if (sargc >= MAX_ARGS - 1) { + arg_overflow: + rprintf(FERROR, "internal: args[] overflowed in do_cmd()\n"); + exit_cleanup(RERR_SYNTAX); + } + if (strncmp(*argv, modname, modlen) == 0 + && argv[0][modlen] == '\0') + sargs[sargc++] = modname; /* we send "modname/" */ + else + sargs[sargc++] = *argv; + argv++; + argc--; + } sargs[sargc] = NULL; if (verbose > 1) - print_child_argv(sargs); + print_child_argv("sending daemon args:", sargs); - p = strchr(path,'/'); - if (p) *p = 0; - io_printf(f_out, "%s\n", path); - if (p) *p = '/'; + io_printf(f_out, "%.*s\n", modlen, modname); /* Old servers may just drop the connection here, rather than sending a proper EXIT command. Yuck. */ kluge_around_eof = list_only && protocol_version < 25 ? 1 : 0; while (1) { - if (!read_line(f_in, line, sizeof line - 1)) { + if (!read_line_old(f_in, line, sizeof line)) { rprintf(FERROR, "rsync: didn't get server startup line\n"); return -1; } @@ -214,16 +312,25 @@ int start_inband_exchange(const char *user, char *path, int f_in, int f_out, } kluge_around_eof = 0; - for (i = 0; i < sargc; i++) { - io_printf(f_out, "%s\n", sargs[i]); + if (rl_nulls) { + for (i = 0; i < sargc; i++) { + write_sbuf(f_out, sargs[i]); + write_byte(f_out, 0); + } + write_byte(f_out, 0); + } else { + for (i = 0; i < sargc; i++) + io_printf(f_out, "%s\n", sargs[i]); + write_sbuf(f_out, "\n"); } - io_printf(f_out, "\n"); if (protocol_version < 23) { if (protocol_version == 22 || !am_sender) io_start_multiplex_in(); } + free(modname); + return 0; } @@ -232,12 +339,12 @@ static char *finish_pre_exec(pid_t pid, int fd, char *request, { int j, status = -1; - if (request) { - write_buf(fd, request, strlen(request)+1); - for (j = 0; j < argc; j++) - write_buf(fd, argv[j], strlen(argv[j])+1); - } + if (!request) + request = "(NONE)"; + write_buf(fd, request, strlen(request)+1); + for (j = 0; j < argc; j++) + write_buf(fd, argv[j], strlen(argv[j])+1); write_byte(fd, 0); close(fd); @@ -259,8 +366,12 @@ static int read_arg_from_pipe(int fd, char *buf, int limit) char *bp = buf, *eob = buf + limit - 1; while (1) { - if (read(fd, bp, 1) != 1) + int got = read(fd, bp, 1); + if (got != 1) { + if (got < 0 && errno == EINTR) + continue; return -1; + } if (*bp == '\0') break; if (bp < eob) @@ -273,20 +384,25 @@ static int read_arg_from_pipe(int fd, char *buf, int limit) static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) { - int argc = 0; - int maxargs; - char **argv; + int argc, opt_cnt; + char **argv, *chroot_path = NULL; char line[BIGPATHBUFLEN]; uid_t uid = (uid_t)-2; /* canonically "nobody" */ gid_t gid = (gid_t)-2; char *p, *err_msg = NULL; char *name = lp_name(i); int use_chroot = lp_use_chroot(i); - int start_glob = 0; int ret, pre_exec_fd = -1; pid_t pre_exec_pid = 0; char *request = NULL; +#ifdef ICONV_OPTION + iconv_opt = lp_charset(i); + if (*iconv_opt) + setup_iconv(); + iconv_opt = NULL; +#endif + if (!allow_access(addr, host, lp_hosts_allow(i), lp_hosts_deny(i))) { rprintf(FLOG, "rsync denied on module %s from %s (%s)\n", name, host, addr); @@ -369,11 +485,36 @@ static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) /* TODO: Perhaps take a list of gids, and make them into the * supplementary groups. */ - if (use_chroot || (module_dirlen = strlen(lp_path(i))) == 1) { + module_dir = lp_path(i); + if (use_chroot) { + if ((p = strstr(module_dir, "/./")) != NULL) { + *p = '\0'; + p += 2; + } else if ((p = strdup("/")) == NULL) + out_of_memory("rsync_module"); + } + + /* We do a push_dir() that doesn't actually call chdir() + * just to make a relative path absolute. */ + strlcpy(line, curr_dir, sizeof line); + if (!push_dir(module_dir, 1)) + goto chdir_failed; + if (strcmp(curr_dir, module_dir) != 0 + && (module_dir = strdup(curr_dir)) == NULL) + out_of_memory("rsync_module"); + push_dir(line, 1); /* Restore curr_dir. */ + + if (use_chroot) { + chroot_path = module_dir; + module_dir = p; /* p is "/" or our inside-chroot path */ + } + module_dirlen = clean_fname(module_dir, CFN_COLLAPSE_DOT_DOT_DIRS | CFN_DROP_TRAILING_DOT_DIR); + + if (module_dirlen == 1) { module_dirlen = 0; set_filter_dir("/", 1); } else - set_filter_dir(lp_path(i), module_dirlen); + set_filter_dir(module_dir, module_dirlen); p = lp_filter(i); parse_rule(&server_filter_list, p, MATCHFLG_WORD_SPLIT, @@ -402,8 +543,17 @@ static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) if (*lp_prexfer_exec(i) || *lp_postxfer_exec(i)) { char *modname, *modpath, *hostaddr, *hostname, *username; int status; + + if (!use_chroot) + p = module_dir; + else if (module_dirlen) { + pathjoin(line, sizeof line, chroot_path, module_dir+1); + p = line; + } else + p = chroot_path; + if (asprintf(&modname, "RSYNC_MODULE_NAME=%s", name) < 0 - || asprintf(&modpath, "RSYNC_MODULE_PATH=%s", lp_path(i)) < 0 + || asprintf(&modpath, "RSYNC_MODULE_PATH=%s", p) < 0 || asprintf(&hostaddr, "RSYNC_HOST_ADDR=%s", addr) < 0 || asprintf(&hostname, "RSYNC_HOST_NAME=%s", host) < 0 || asprintf(&username, "RSYNC_USER_NAME=%s", auth_user) < 0) @@ -503,30 +653,37 @@ static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) * a warning, unless a "require chroot" flag is set, * in which case we fail. */ - if (chroot(lp_path(i))) { - rsyserr(FLOG, errno, "chroot %s failed", - lp_path(i)); + if (chroot(chroot_path)) { + rsyserr(FLOG, errno, "chroot %s failed", chroot_path); io_printf(f_out, "@ERROR: chroot failed\n"); return -1; } - - if (!push_dir("/", 0)) { - rsyserr(FLOG, errno, "chdir %s failed\n", - lp_path(i)); - io_printf(f_out, "@ERROR: chdir failed\n"); - return -1; - } - + if (!push_dir(module_dir, 0)) + goto chdir_failed; + if (module_dirlen) + sanitize_paths = 1; } else { - if (!push_dir(lp_path(i), 0)) { - rsyserr(FLOG, errno, "chdir %s failed\n", - lp_path(i)); + if (!push_dir(module_dir, 0)) { + chdir_failed: + rsyserr(FLOG, errno, "chdir %s failed\n", module_dir); io_printf(f_out, "@ERROR: chdir failed\n"); return -1; } sanitize_paths = 1; } + if ((munge_symlinks = lp_munge_symlinks(i)) < 0) + munge_symlinks = !use_chroot || module_dirlen; + if (munge_symlinks) { + STRUCT_STAT st; + if (stat(SYMLINK_PREFIX, &st) == 0 && S_ISDIR(st.st_mode)) { + rprintf(FLOG, "Symlink munging is unsupported when a %s directory exists.\n", + SYMLINK_PREFIX); + io_printf(f_out, "@ERROR: daemon security issue -- contact admin\n", name); + exit_cleanup(RERR_UNSUPPORTED); + } + } + if (am_root) { /* XXXX: You could argue that if the daemon is started * by a non-root user and they explicitly specify a @@ -574,61 +731,27 @@ static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) io_printf(f_out, "@RSYNCD: OK\n"); - maxargs = MAX_ARGS; - if (!(argv = new_array(char *, maxargs))) - out_of_memory("rsync_module"); - argv[argc++] = "rsyncd"; - - while (1) { - if (!read_line(f_in, line, sizeof line - 1)) - return -1; - - if (!*line) - break; - - p = line; - - if (argc == maxargs) { - maxargs += MAX_ARGS; - if (!(argv = realloc_array(argv, char *, maxargs))) - out_of_memory("rsync_module"); - } - if (!(argv[argc] = strdup(p))) - out_of_memory("rsync_module"); - - switch (start_glob) { - case 0: - argc++; - if (strcmp(line, ".") == 0) - start_glob = 1; - break; - case 1: - if (pre_exec_pid) { - err_msg = finish_pre_exec(pre_exec_pid, - pre_exec_fd, p, - argc, argv); - pre_exec_pid = 0; - } - request = strdup(p); - start_glob = 2; - /* FALL THROUGH */ - default: - if (!err_msg) - glob_expand(name, &argv, &argc, &maxargs); - break; - } - } + opt_cnt = read_args(f_in, name, line, sizeof line, rl_nulls, &argv, &argc, &request); if (pre_exec_pid) { err_msg = finish_pre_exec(pre_exec_pid, pre_exec_fd, request, - argc, argv); + opt_cnt, argv); } verbose = 0; /* future verbosity is controlled by client options */ ret = parse_arguments(&argc, (const char ***) &argv, 0); - quiet = 0; /* Don't let someone try to be tricky. */ + am_server = 1; /* Don't let someone try to be tricky. */ if (lp_ignore_errors(module_id)) ignore_errors = 1; + if (write_batch < 0) + dry_run = 1; + + if (lp_fake_super(i)) { + if (preserve_xattrs > 1) + preserve_xattrs = 1; + am_root = -1; + } else if (am_root < 0) /* Treat --fake-super from client as --super. */ + am_root = 2; if (filesfrom_fd == 0) filesfrom_fd = f_in; @@ -683,13 +806,30 @@ static int rsync_module(int f_in, int f_out, int i, char *addr, char *host) if (!ret || err_msg) { if (err_msg) - rwrite(FERROR, err_msg, strlen(err_msg)); + rwrite(FERROR, err_msg, strlen(err_msg), 0); else option_error(); msleep(400); exit_cleanup(RERR_UNSUPPORTED); } +#ifdef ICONV_OPTION + if (!iconv_opt) { + if (ic_send != (iconv_t)-1) { + iconv_close(ic_send); + ic_send = (iconv_t)-1; + } + if (ic_recv != (iconv_t)-1) { + iconv_close(ic_recv); + ic_recv = (iconv_t)-1; + } + } +#endif + + if (!numeric_ids + && (use_chroot ? lp_numeric_ids(i) != False : lp_numeric_ids(i) == True)) + numeric_ids = -1; /* Set --numeric-ids w/o breaking protocol. */ + if (lp_timeout(i) && lp_timeout(i) > io_timeout) set_io_timeout(lp_timeout(i)); @@ -727,13 +867,24 @@ static void send_listing(int fd) io_printf(fd,"@RSYNCD: EXIT\n"); } +static int load_config(int globals_only) +{ + if (!config_file) { + if (am_server && am_root <= 0) + config_file = RSYNCD_USERCONF; + else + config_file = RSYNCD_SYSCONF; + } + return lp_load(config_file, globals_only); +} + /* this is called when a connection is established to a client and we want to start talking. The setup of the system is done from here */ int start_daemon(int f_in, int f_out) { char line[1024]; - char *motd, *addr, *host; + char *addr, *host; int i; io_set_sock_fds(f_in, f_out); @@ -742,7 +893,7 @@ int start_daemon(int f_in, int f_out) * might cause log-file output to occur. This ensures that the * "log file" param gets honored for the 2 non-forked use-cases * (when rsync is run by init and run by a remote shell). */ - if (!lp_load(config_file, 0)) + if (!load_config(0)) exit_cleanup(RERR_SYNTAX); addr = client_addr(f_in); @@ -758,35 +909,11 @@ int start_daemon(int f_in, int f_out) set_nonblocking(f_in); } - io_printf(f_out, "@RSYNCD: %d\n", protocol_version); - - motd = lp_motd_file(); - if (motd && *motd) { - FILE *f = fopen(motd,"r"); - while (f && !feof(f)) { - int len = fread(line, 1, sizeof line - 1, f); - if (len > 0) { - line[len] = 0; - io_printf(f_out, "%s", line); - } - } - if (f) - fclose(f); - io_printf(f_out, "\n"); - } - - if (!read_line(f_in, line, sizeof line - 1)) + if (exchange_protocols(f_in, f_out, line, sizeof line, 0) < 0) return -1; - if (sscanf(line,"@RSYNCD: %d", &remote_protocol) != 1) { - io_printf(f_out, "@ERROR: protocol startup error\n"); - return -1; - } - if (protocol_version > remote_protocol) - protocol_version = remote_protocol; - line[0] = 0; - if (!read_line(f_in, line, sizeof line - 1)) + if (!read_line_old(f_in, line, sizeof line)) return -1; if (!*line || strcmp(line, "#list") == 0) { @@ -817,10 +944,64 @@ int start_daemon(int f_in, int f_out) return rsync_module(f_in, f_out, i, addr, host); } -int daemon_main(void) +static void create_pid_file(void) +{ + char *pid_file = lp_pid_file(); + char pidbuf[16]; + pid_t pid = getpid(); + int fd; + + if (!pid_file || !*pid_file) + return; + + cleanup_set_pid(pid); + if ((fd = do_open(pid_file, O_WRONLY|O_CREAT|O_EXCL, 0666 & ~orig_umask)) == -1) { + cleanup_set_pid(0); + fprintf(stderr, "failed to create pid file %s: %s\n", pid_file, strerror(errno)); + rsyserr(FLOG, errno, "failed to create pid file %s", pid_file); + exit_cleanup(RERR_FILEIO); + } + snprintf(pidbuf, sizeof pidbuf, "%ld\n", (long)pid); + write(fd, pidbuf, strlen(pidbuf)); + close(fd); +} + +/* Become a daemon, discarding the controlling terminal. */ +static void become_daemon(void) { - char *pid_file; + int i; + pid_t pid = fork(); + + if (pid) { + if (pid < 0) { + fprintf(stderr, "failed to fork: %s\n", strerror(errno)); + exit_cleanup(RERR_FILEIO); + } + _exit(0); + } + + create_pid_file(); + /* detach from the terminal */ +#ifdef HAVE_SETSID + setsid(); +#elif defined TIOCNOTTY + i = open("/dev/tty", O_RDWR); + if (i >= 0) { + ioctl(i, (int)TIOCNOTTY, (char *)0); + close(i); + } +#endif + /* make sure that stdin, stdout an stderr don't stuff things + * up (library functions, for example) */ + for (i = 0; i < 3; i++) { + close(i); + open("/dev/null", O_RDWR); + } +} + +int daemon_main(void) +{ if (is_a_socket(STDIN_FILENO)) { int i; @@ -835,11 +1016,15 @@ int daemon_main(void) return start_daemon(STDIN_FILENO, STDIN_FILENO); } - if (!no_detach) - become_daemon(); - - if (!lp_load(config_file, 1)) + if (!load_config(1)) { + fprintf(stderr, "Failed to parse config file: %s\n", config_file); exit_cleanup(RERR_SYNTAX); + } + + if (no_detach) + create_pid_file(); + else + become_daemon(); if (rsync_port == 0 && (rsync_port = lp_rsync_port()) == 0) rsync_port = RSYNC_PORT; @@ -854,23 +1039,6 @@ int daemon_main(void) * address too. In fact, why not just do inet_ntop on the * local address??? */ - if (((pid_file = lp_pid_file()) != NULL) && (*pid_file != '\0')) { - char pidbuf[16]; - int fd; - pid_t pid = getpid(); - cleanup_set_pid(pid); - if ((fd = do_open(lp_pid_file(), O_WRONLY|O_CREAT|O_TRUNC, - 0666 & ~orig_umask)) == -1) { - cleanup_set_pid(0); - rsyserr(FLOG, errno, "failed to create pid file %s", - pid_file); - exit_cleanup(RERR_FILEIO); - } - snprintf(pidbuf, sizeof pidbuf, "%ld\n", (long)pid); - write(fd, pidbuf, strlen(pidbuf)); - close(fd); - } - start_accept_loop(rsync_port, start_daemon); return -1; }