| 1 | Eran Tromer writes: |
| 2 | |
| 3 | One feature missing from rsync, and requested on this list before, is |
| 4 | on-the-fly conversion of filename character encoding. For example, I |
| 5 | often need to sync files having Hebrew filenames from a UTF-8 system |
| 6 | (Linux) to an ISO8859-8 system (Cygwin on Windows 2000 using the |
| 7 | non-Unicode Win32 interface). Other circumstances surely abound. |
| 8 | |
| 9 | Attached is a patch against rsync 2.6.2 that adds an "--fname-convert" |
| 10 | option. When the argument "--fname-convert CONV" is given, rsync pipes |
| 11 | every filename through the program CONV, and filename presented to the |
| 12 | server will be CONV's output instead of the raw filename. |
| 13 | |
| 14 | Artificial example: |
| 15 | $ touch /tmp/xyz |
| 16 | $ rsync -fname-convert 'tr y Y' /tmp/xyz /tmp/ |
| 17 | $ ls /tmp/x?z |
| 18 | /tmp/xyz /tmp/xYz |
| 19 | |
| 20 | Perhaps the most useful case is using iconv: |
| 21 | $ rsync --fname-convert 'iconv -f utf8 -t iso8859-8' ... |
| 22 | |
| 23 | I chose to allow invocation of arbitrary programs instead of using |
| 24 | libiconv (or equivalent) in order to avoid external dependencies, and to |
| 25 | offer more flexibility. The price is that some heuristics were needed to |
| 26 | avoid the deadlock problems that tend to occur when filtering data |
| 27 | through a program that uses buffered I/O -- see the comments at the top |
| 28 | of the new file fnameconv.c. The delay you may have noticed in the above |
| 29 | artificial example using "tr" is due to these heuristics; it occurs just |
| 30 | once per rsync invocation, not for every file. |
| 31 | |
| 32 | I believe there are no server-side security implications, since all |
| 33 | conversion is done at the client and the server is oblivious to it. On |
| 34 | the client, conversion is done before sanitize_path() and besides, |
| 35 | providing a sane converter program is the client's responsibility anyway. |
| 36 | |
| 37 | In verbose mode the updating of non-regular files is reported via |
| 38 | rprintf() by the server, so the client will see the converted filename |
| 39 | instead the raw filename -- see my comment in recv_generator(). Fixing |
| 40 | this requires some delicate changes so I left it as is, but it seems |
| 41 | like a minor concern. |
| 42 | |
| 43 | Most of the new code is in the new file fnameconv.c. The patch lightly |
| 44 | touches some other files, mostly flist.c and the addition/extension of |
| 45 | some utility functions. |
| 46 | |
| 47 | Note that you'll need to run 'make proto' after applying this patch. |
| 48 | |
| 49 | |
| 50 | --- orig/Makefile.in 2004-07-04 08:59:17 |
| 51 | +++ Makefile.in 2004-07-03 20:18:02 |
| 52 | @@ -35,7 +35,7 @@ OBJS1=rsync.o generator.o receiver.o cle |
| 53 | main.o checksum.o match.o syscall.o log.o backup.o |
| 54 | OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o \ |
| 55 | fileio.o batch.o clientname.o |
| 56 | -OBJS3=progress.o pipe.o |
| 57 | +OBJS3=progress.o pipe.o fnameconv.o |
| 58 | DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o |
| 59 | popt_OBJS=popt/findme.o popt/popt.o popt/poptconfig.o \ |
| 60 | popt/popthelp.o popt/poptparse.o |
| 61 | --- orig/cleanup.c 2004-07-20 21:36:07 |
| 62 | +++ cleanup.c 2004-07-03 20:18:02 |
| 63 | @@ -24,6 +24,7 @@ |
| 64 | extern int io_error; |
| 65 | extern int keep_partial; |
| 66 | extern int log_got_error; |
| 67 | +extern char *fname_convert_cmd; |
| 68 | |
| 69 | /** |
| 70 | * Close all open sockets and files, allowing a (somewhat) graceful |
| 71 | @@ -121,6 +122,8 @@ void _exit_cleanup(int code, const char |
| 72 | finish_transfer(cleanup_new_fname, fname, cleanup_file, 0); |
| 73 | } |
| 74 | io_flush(FULL_FLUSH); |
| 75 | + if (fname_convert_cmd) |
| 76 | + cleanup_fname_convert(); |
| 77 | if (cleanup_fname) |
| 78 | do_unlink(cleanup_fname); |
| 79 | if (code) |
| 80 | --- orig/errcode.h 2003-12-15 08:04:14 |
| 81 | +++ errcode.h 2004-07-02 21:38:59 |
| 82 | @@ -34,6 +34,7 @@ |
| 83 | #define RERR_STREAMIO 12 /* error in rsync protocol data stream */ |
| 84 | #define RERR_MESSAGEIO 13 /* errors with program diagnostics */ |
| 85 | #define RERR_IPC 14 /* error in IPC code */ |
| 86 | +#define RERR_FNAMECONV 15 /* error in filename conversion */ |
| 87 | |
| 88 | #define RERR_SIGNAL 20 /* status returned when sent SIGUSR1, SIGINT */ |
| 89 | #define RERR_WAITCHILD 21 /* some error returned by waitpid() */ |
| 90 | --- orig/flist.c 2004-07-17 15:20:05 |
| 91 | +++ flist.c 2004-07-03 20:18:02 |
| 92 | @@ -43,6 +43,7 @@ extern int cvs_exclude; |
| 93 | |
| 94 | extern int recurse; |
| 95 | extern char curr_dir[MAXPATHLEN]; |
| 96 | +extern char *fname_convert_cmd; |
| 97 | extern char *files_from; |
| 98 | extern int filesfrom_fd; |
| 99 | |
| 100 | @@ -357,7 +358,10 @@ void send_file_entry(struct file_struct |
| 101 | |
| 102 | io_write_phase = "send_file_entry"; |
| 103 | |
| 104 | - f_name_to(file, fname); |
| 105 | + if (fname_convert_cmd && !am_server) /* fname conversion always done on client */ |
| 106 | + convert_fname(fname, f_name(file), MAXPATHLEN); |
| 107 | + else |
| 108 | + f_name_to(file, fname); |
| 109 | |
| 110 | flags = base_flags; |
| 111 | |
| 112 | @@ -570,6 +574,9 @@ void receive_file_entry(struct file_stru |
| 113 | |
| 114 | strlcpy(lastname, thisname, MAXPATHLEN); |
| 115 | |
| 116 | + if (fname_convert_cmd && !am_server) /* fname conversion always done on client */ |
| 117 | + convert_fname(thisname, lastname, MAXPATHLEN); |
| 118 | + |
| 119 | clean_fname(thisname); |
| 120 | |
| 121 | if (sanitize_paths) |
| 122 | @@ -1055,6 +1062,9 @@ struct file_list *send_file_list(int f, |
| 123 | |
| 124 | start_write = stats.total_written; |
| 125 | |
| 126 | + if (!am_server) |
| 127 | + init_fname_convert(); |
| 128 | + |
| 129 | flist = flist_new(f == -1 ? WITHOUT_HLINK : WITH_HLINK, |
| 130 | "send_file_list"); |
| 131 | |
| 132 | @@ -1227,6 +1237,9 @@ struct file_list *send_file_list(int f, |
| 133 | stats.num_files = flist->count; |
| 134 | } |
| 135 | |
| 136 | + if (fname_convert_cmd && !am_server) |
| 137 | + cleanup_fname_convert(); |
| 138 | + |
| 139 | if (verbose > 3) |
| 140 | output_flist(flist); |
| 141 | |
| 142 | @@ -1248,6 +1261,9 @@ struct file_list *recv_file_list(int f) |
| 143 | |
| 144 | start_read = stats.total_read; |
| 145 | |
| 146 | + if (fname_convert_cmd && !am_server) |
| 147 | + init_fname_convert(); |
| 148 | + |
| 149 | flist = flist_new(WITH_HLINK, "recv_file_list"); |
| 150 | |
| 151 | flist->count = 0; |
| 152 | @@ -1300,6 +1316,9 @@ struct file_list *recv_file_list(int f) |
| 153 | io_error |= read_int(f); |
| 154 | } |
| 155 | |
| 156 | + if (fname_convert_cmd && !am_server) |
| 157 | + cleanup_fname_convert(); |
| 158 | + |
| 159 | if (verbose > 3) |
| 160 | output_flist(flist); |
| 161 | |
| 162 | --- orig/fnameconv.c 2004-07-02 21:38:59 |
| 163 | +++ fnameconv.c 2004-07-02 21:38:59 |
| 164 | @@ -0,0 +1,220 @@ |
| 165 | +/* -*- c-file-style: "linux" -*- |
| 166 | + * |
| 167 | + * Copyright (C) 2004 by Eran Tromer |
| 168 | + * |
| 169 | + * This program is free software; you can redistribute it and/or modify |
| 170 | + * it under the terms of the GNU General Public License as published by |
| 171 | + * the Free Software Foundation; either version 2 of the License, or |
| 172 | + * (at your option) any later version. |
| 173 | + * |
| 174 | + * This program is distributed in the hope that it will be useful, |
| 175 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 176 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 177 | + * GNU General Public License for more details. |
| 178 | + * |
| 179 | + * You should have received a copy of the GNU General Public License |
| 180 | + * along with this program; if not, write to the Free Software |
| 181 | + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 182 | + */ |
| 183 | + |
| 184 | +/* Handles filename conversion through an external process. Implements |
| 185 | + * two modes of operation: |
| 186 | + * In persistent mode, a single filename converter is kept running; |
| 187 | + * for each query we feed it a single line and read back a single |
| 188 | + * line. This will fail for programs that used buffered I/O, and will |
| 189 | + * get into a deadlock. |
| 190 | + * In non-persistent mode, a converter is invoked and killed for each |
| 191 | + * query. This has a very high overhead, but will work for any |
| 192 | + * program. |
| 193 | + * We start in persistence mode, and if we suspect a deadlock (i.e., |
| 194 | + * nothing happens for FNAME_CONV_PERSISTENCE_TIMEOUT milliseconds) |
| 195 | + * then we smoothly fall back to non-persistent mode. |
| 196 | + * |
| 197 | + * Filename conversion errors are always considered fatal, since an |
| 198 | + * incorrectly named file could cause unpredictable damage. |
| 199 | + */ |
| 200 | + |
| 201 | +#include <rsync.h> |
| 202 | + |
| 203 | +#define FNAME_CONV_PERSISTENCE_TIMEOUT 3000 /* milliseconds */ |
| 204 | + |
| 205 | +static int conv_persistent = 1; |
| 206 | +static pid_t conv_pid = -1; |
| 207 | +static int conv_write_fd = -1, conv_read_fd; |
| 208 | +extern char *fname_convert_cmd; |
| 209 | +extern int blocking_io; |
| 210 | + |
| 211 | +/** |
| 212 | + * Splits cmd on spaces. |
| 213 | + */ |
| 214 | +static void split_on_spaces(char *cmd, char **parts) { |
| 215 | + int nparts = 0; |
| 216 | + char *tok; |
| 217 | + char *cmd2 = strdup(cmd); |
| 218 | + if (!cmd2) { |
| 219 | + rprintf(FERROR, "Out of memory while parsing filename filter %s\n", cmd); |
| 220 | + exit_cleanup(RERR_MALLOC); |
| 221 | + } |
| 222 | + |
| 223 | + for (tok = strtok(cmd2, " "); tok; tok = strtok(NULL, " ")) { |
| 224 | + if (nparts >= MAX_ARGS) { |
| 225 | + rprintf(FERROR, "Filename conversion command is too long: %s\n", cmd); |
| 226 | + exit_cleanup(RERR_SYNTAX); |
| 227 | + } |
| 228 | + parts[nparts++] = tok; |
| 229 | + } |
| 230 | + parts[nparts] = NULL; |
| 231 | +} |
| 232 | + |
| 233 | + |
| 234 | +/** |
| 235 | + * Runs the filename converter process. Should be called before filename |
| 236 | + * conversion begins (actually it's not necessarh, but it keeps the proress report |
| 237 | + * nice and clean. |
| 238 | + **/ |
| 239 | +void init_fname_convert() |
| 240 | +{ |
| 241 | + if (fname_convert_cmd && conv_pid < 0) { |
| 242 | + char *args[MAX_ARGS]; |
| 243 | + |
| 244 | + if (verbose > 2) |
| 245 | + rprintf(FINFO, "Running filename converter: %s\n", fname_convert_cmd); |
| 246 | + split_on_spaces(fname_convert_cmd, args); |
| 247 | + /* Invoke child pipe with non-blocking IO and without registering it for |
| 248 | + * autocleanup (the latter may blow up the all_pids table, and is not needed |
| 249 | + * since we have our own cleanup handler. */ |
| 250 | + conv_pid = piped_child(args, &conv_read_fd, &conv_write_fd, 0, 0); |
| 251 | + set_nonblocking(conv_write_fd); |
| 252 | + set_nonblocking(conv_read_fd); |
| 253 | + } |
| 254 | +} |
| 255 | + |
| 256 | +/** |
| 257 | + * Kills the filename converter process. Should be called when the file |
| 258 | + * list creation is done. We assume that the converter will terminate |
| 259 | + * soon after its standard input is closed. |
| 260 | + **/ |
| 261 | +void cleanup_fname_convert() |
| 262 | +{ |
| 263 | + if (conv_pid >= 0) { |
| 264 | + int status; |
| 265 | + if (conv_write_fd >= 0) { |
| 266 | + close(conv_write_fd); |
| 267 | + conv_write_fd = -1; |
| 268 | + } |
| 269 | + close(conv_read_fd); |
| 270 | + waitpid(conv_pid, &status, 0); |
| 271 | + conv_pid = -1; |
| 272 | + } |
| 273 | +} |
| 274 | + |
| 275 | +/** |
| 276 | + * Converts the filename from src into dest, using at most maxlen |
| 277 | + * characters of dest. |
| 278 | + **/ |
| 279 | +void convert_fname(char *dest, const char *src, unsigned int maxlen) |
| 280 | +{ |
| 281 | + int res; |
| 282 | + const char *srcp; |
| 283 | + char *destp; |
| 284 | + unsigned int srcrem, dstrem; |
| 285 | + |
| 286 | + init_fname_convert(); |
| 287 | + |
| 288 | + /* Send and receive strings simultaneously to avoid deadlock: */ |
| 289 | + srcrem = strlen(src)+1; /* chars left to send (incl. terminating LF) */ |
| 290 | + dstrem = maxlen-1; /* free chars left in dest */ |
| 291 | + srcp = src; |
| 292 | + destp = dest; |
| 293 | + while(1) { |
| 294 | + /* Write as much as possible: */ |
| 295 | + if (srcrem > 1) { |
| 296 | + res = write(conv_write_fd, srcp, srcrem-1); |
| 297 | + if (res < 0 && errno != EAGAIN) { |
| 298 | + rprintf(FERROR, "Error writing to fname converter (filename: %s): %s\n", strerror(errno), src); |
| 299 | + exit_cleanup(RERR_FNAMECONV); |
| 300 | + } |
| 301 | + if (res > 0) { /* wrote something */ |
| 302 | + srcp += res; |
| 303 | + srcrem -= res; |
| 304 | + } |
| 305 | + } |
| 306 | + if (srcrem == 1) { /* final LF */ |
| 307 | + res = write(conv_write_fd, "\n", 1); |
| 308 | + if (res < 0 && errno != EAGAIN) { |
| 309 | + rprintf(FERROR, "Error writing to fname converter (filename: %s): %s\n", strerror(errno), src); |
| 310 | + exit_cleanup(RERR_FNAMECONV); |
| 311 | + } |
| 312 | + if (res > 0) { /* wrote final LF */ |
| 313 | + srcrem = 0; |
| 314 | + if (!conv_persistent) { |
| 315 | + close(conv_write_fd); |
| 316 | + conv_write_fd = -1; |
| 317 | + } |
| 318 | + } |
| 319 | + } |
| 320 | + |
| 321 | + /* Read as much as possible: */ |
| 322 | + res = read(conv_read_fd, destp, dstrem); |
| 323 | + if (res < 0 && errno != EAGAIN) { |
| 324 | + rprintf(FERROR, "Error reading from filename converter (filename: %s):%s \n", strerror(errno), src); |
| 325 | + exit_cleanup(RERR_FNAMECONV); |
| 326 | + } |
| 327 | + if (res == 0) { /* EOF */ |
| 328 | + rprintf(FERROR, "EOF from filename converter (filename: %s)\n", src); |
| 329 | + exit_cleanup(RERR_FNAMECONV); |
| 330 | + } |
| 331 | + if (res > 0) { |
| 332 | + destp += res; |
| 333 | + dstrem -= res; |
| 334 | + if (destp[-1] == '\n' || destp[-1] == '\r') |
| 335 | + break; /* End of line. Yippy! */ |
| 336 | + if (dstrem == 0) { |
| 337 | + rprintf(FINFO, "Name converter output too long (filename: %s)\n", src); |
| 338 | + exit_cleanup(RERR_FNAMECONV); |
| 339 | + } |
| 340 | + } |
| 341 | + |
| 342 | + /* Await activity */ |
| 343 | + if (!await_fds(conv_read_fd, !srcrem ? -1 : conv_write_fd, FNAME_CONV_PERSISTENCE_TIMEOUT)) { |
| 344 | + if (srcrem == 0 && conv_persistent) { |
| 345 | + /* We finished writing but nothing happens. It looks like the converter program |
| 346 | + * is using buffered I/O and thus wait to read more input, but we can't give it |
| 347 | + * the next filename yet. Fall back to non-persistent mode. */ |
| 348 | + if (verbose > 0) |
| 349 | + rprintf(FINFO, "Filename converter blocked, disabling persistence to recover.\n"); |
| 350 | + |
| 351 | + conv_persistent = 0; |
| 352 | + close(conv_write_fd); |
| 353 | + conv_write_fd = -1; |
| 354 | + } |
| 355 | + } |
| 356 | + } |
| 357 | + |
| 358 | + /* Cleanup and sanity check */ |
| 359 | + if (!conv_persistent) |
| 360 | + cleanup_fname_convert(); |
| 361 | + if (srcrem > 0) { |
| 362 | + close(conv_write_fd); |
| 363 | + rprintf(FERROR, "Name converter produced output before reading all its input for file: %s\n", src); |
| 364 | + exit_cleanup(RERR_FNAMECONV); |
| 365 | + } |
| 366 | + |
| 367 | + /* Chop newline chars */ |
| 368 | + destp--; |
| 369 | + if (destp > dest && *destp == '\n') |
| 370 | + --destp; |
| 371 | + if (destp > dest && *destp == '\r') |
| 372 | + --destp; |
| 373 | + if (++destp == dest) { |
| 374 | + rprintf(FERROR, "Name converter output is empty (filename: %s)\n", src); |
| 375 | + exit_cleanup(RERR_FNAMECONV); |
| 376 | + } |
| 377 | + *destp = 0; |
| 378 | + /* Also, we may have a leading CR left over from a CRLF of the previous line */ |
| 379 | + if (*dest == '\n') |
| 380 | + memmove(dest, dest+1, destp-dest-1); |
| 381 | + |
| 382 | + if (verbose > 2) |
| 383 | + rprintf(FINFO, "Converted filename: %s -> %s\n", src, dest); |
| 384 | +} |
| 385 | --- orig/generator.c 2004-07-21 23:59:35 |
| 386 | +++ generator.c 2004-07-03 20:18:02 |
| 387 | @@ -256,6 +256,12 @@ static void generate_and_send_sums(int f |
| 388 | * |
| 389 | * @note This comment was added later by mbp who was trying to work it |
| 390 | * out. It might be wrong. |
| 391 | + * |
| 392 | + * TODO: The filename seen in recv_generator is after filename |
| 393 | + * conversion. In verbose mode, directories, symlinks and device |
| 394 | + * files are printf()ed here but regular files are rprintf()ed on the |
| 395 | + * sender (unconverted). To solve the above, move all progress |
| 396 | + * reporting to the sender. |
| 397 | */ |
| 398 | static void recv_generator(char *fname, struct file_struct *file, int i, |
| 399 | int f_out) |
| 400 | --- orig/log.c 2004-06-09 15:34:38 |
| 401 | +++ log.c 2004-07-03 20:18:02 |
| 402 | @@ -57,6 +57,7 @@ struct { |
| 403 | { RERR_STREAMIO , "error in rsync protocol data stream" }, |
| 404 | { RERR_MESSAGEIO , "errors with program diagnostics" }, |
| 405 | { RERR_IPC , "error in IPC code" }, |
| 406 | + { RERR_FNAMECONV , "error in filename conversion" }, |
| 407 | { RERR_SIGNAL , "received SIGUSR1 or SIGINT" }, |
| 408 | { RERR_WAITCHILD , "some error returned by waitpid()" }, |
| 409 | { RERR_MALLOC , "error allocating core memory buffers" }, |
| 410 | --- orig/main.c 2004-07-21 23:59:35 |
| 411 | +++ main.c 2004-07-22 00:31:47 |
| 412 | @@ -329,7 +329,7 @@ static pid_t do_cmd(char *cmd, char *mac |
| 413 | whole_file = 1; |
| 414 | ret = local_child(argc, args, f_in, f_out, child_main); |
| 415 | } else |
| 416 | - ret = piped_child(args,f_in,f_out); |
| 417 | + ret = piped_child(args, f_in, f_out, blocking_io, 1); |
| 418 | |
| 419 | if (dir) |
| 420 | free(dir); |
| 421 | --- orig/options.c 2004-07-21 23:59:35 |
| 422 | +++ options.c 2004-07-03 20:18:02 |
| 423 | @@ -128,6 +128,7 @@ char *backup_dir = NULL; |
| 424 | char backup_dir_buf[MAXPATHLEN]; |
| 425 | int rsync_port = RSYNC_PORT; |
| 426 | int link_dest = 0; |
| 427 | +char *fname_convert_cmd = NULL; |
| 428 | |
| 429 | int verbose = 0; |
| 430 | int quiet = 0; |
| 431 | @@ -277,6 +278,7 @@ void usage(enum logcode F) |
| 432 | rprintf(F," --compare-dest=DIR also compare destination files relative to DIR\n"); |
| 433 | rprintf(F," --link-dest=DIR create hardlinks to DIR for unchanged files\n"); |
| 434 | rprintf(F," -P equivalent to --partial --progress\n"); |
| 435 | + rprintf(F," --fname-convert=CMD invoke CMD for filename conversion\n"); |
| 436 | rprintf(F," -z, --compress compress file data\n"); |
| 437 | rprintf(F," -C, --cvs-exclude auto ignore files in the same way CVS does\n"); |
| 438 | rprintf(F," --exclude=PATTERN exclude files matching PATTERN\n"); |
| 439 | @@ -375,6 +377,7 @@ static struct poptOption long_options[] |
| 440 | {"temp-dir", 'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 }, |
| 441 | {"compare-dest", 0, POPT_ARG_STRING, &compare_dest, 0, 0, 0 }, |
| 442 | {"link-dest", 0, POPT_ARG_STRING, &compare_dest, OPT_LINK_DEST, 0, 0 }, |
| 443 | + {"fname-convert", 0, POPT_ARG_STRING, &fname_convert_cmd, 0, 0, 0 }, |
| 444 | /* TODO: Should this take an optional int giving the compression level? */ |
| 445 | {"compress", 'z', POPT_ARG_NONE, &do_compression, 0, 0, 0 }, |
| 446 | {"daemon", 0, POPT_ARG_NONE, &daemon_opt, 0, 0, 0 }, |
| 447 | --- orig/pipe.c 2004-07-21 23:59:35 |
| 448 | +++ pipe.c 2004-07-03 20:18:02 |
| 449 | @@ -23,7 +23,6 @@ |
| 450 | |
| 451 | extern int am_sender; |
| 452 | extern int am_server; |
| 453 | -extern int blocking_io; |
| 454 | extern int orig_umask; |
| 455 | extern int write_batch; |
| 456 | extern int filesfrom_fd; |
| 457 | @@ -40,8 +39,10 @@ extern int filesfrom_fd; |
| 458 | * If blocking_io is set then use blocking io on both fds. That can be |
| 459 | * used to cope with badly broken rsh implementations like the one on |
| 460 | * Solaris. |
| 461 | + * |
| 462 | + * If register_child is nonzero then the child is registered for autocleanup. |
| 463 | **/ |
| 464 | -pid_t piped_child(char **command, int *f_in, int *f_out) |
| 465 | +pid_t piped_child(char **command, int *f_in, int *f_out, int blocking_io, int register_child) |
| 466 | { |
| 467 | pid_t pid; |
| 468 | int to_child_pipe[2]; |
| 469 | @@ -56,7 +57,7 @@ pid_t piped_child(char **command, int *f |
| 470 | exit_cleanup(RERR_IPC); |
| 471 | } |
| 472 | |
| 473 | - pid = do_fork(); |
| 474 | + pid = register_child ? do_fork() : fork(); |
| 475 | if (pid == -1) { |
| 476 | rsyserr(FERROR, errno, "fork"); |
| 477 | exit_cleanup(RERR_IPC); |
| 478 | --- orig/syscall.c 2004-02-18 22:33:21 |
| 479 | +++ syscall.c 2004-07-02 21:39:00 |
| 480 | @@ -231,3 +231,34 @@ char *d_name(struct dirent *di) |
| 481 | return di->d_name; |
| 482 | #endif |
| 483 | } |
| 484 | + |
| 485 | +/** |
| 486 | + * A wrapper around select(2) that guarantees Linux-like updating of |
| 487 | + * the timeout argument to contain the time left, so we can simply |
| 488 | + * re-invoke in case of EINTR or EAGAIN. On BSD, select(2) doesn't |
| 489 | + * change the timeout argument by itself. |
| 490 | + **/ |
| 491 | +int do_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) |
| 492 | +{ |
| 493 | + struct timeval intended, before, after; |
| 494 | + int result; |
| 495 | + |
| 496 | + if (timeout == NULL) |
| 497 | + return select(n, readfds, writefds, exceptfds, timeout); |
| 498 | + |
| 499 | + intended = *timeout; |
| 500 | + gettimeofday(&before, NULL); |
| 501 | + result = select(n, readfds, writefds, exceptfds, timeout); |
| 502 | + gettimeofday(&after, NULL); |
| 503 | + timeout->tv_sec = intended.tv_sec - (after.tv_sec - before.tv_sec); |
| 504 | + timeout->tv_usec = intended.tv_usec - (after.tv_usec - before.tv_usec); |
| 505 | + if (timeout->tv_usec >= 1000000) { |
| 506 | + ++timeout->tv_sec; |
| 507 | + timeout->tv_usec -= 1000000; |
| 508 | + } else if (timeout->tv_usec < 0) { |
| 509 | + --(timeout)->tv_sec; |
| 510 | + timeout->tv_usec += 1000000; |
| 511 | + } |
| 512 | + |
| 513 | + return result; |
| 514 | +} |
| 515 | --- orig/util.c 2004-06-09 21:54:47 |
| 516 | +++ util.c 2004-07-03 20:18:02 |
| 517 | @@ -1153,3 +1153,55 @@ void *_realloc_array(void *ptr, unsigned |
| 518 | return malloc(size * num); |
| 519 | return realloc(ptr, size * num); |
| 520 | } |
| 521 | + |
| 522 | +/** |
| 523 | + * Blocks until one of the following happens: |
| 524 | + * - read_fd is nonnegative and has data to read |
| 525 | + * - write_fd is nonnegative and can be written to |
| 526 | + * - something terrible happened to either |
| 527 | + * - the timeout (in milliseconds) has elapsed |
| 528 | + * Return value is zero iff the timeout occured. |
| 529 | + */ |
| 530 | +char await_fds(int read_fd, int write_fd, int timeout_ms) |
| 531 | +{ |
| 532 | + fd_set read_fds, write_fds, except_fds; |
| 533 | + struct timeval tv; |
| 534 | + int res; |
| 535 | + |
| 536 | + tv.tv_sec = timeout_ms / 1000; |
| 537 | + tv.tv_usec = (timeout_ms % 1000) * 1000; |
| 538 | + |
| 539 | + while (1) { |
| 540 | + int maxfd = 0; |
| 541 | + FD_ZERO(&read_fds); |
| 542 | + FD_ZERO(&write_fds); |
| 543 | + FD_ZERO(&except_fds); |
| 544 | + if (write_fd >= 0) { |
| 545 | + FD_SET(write_fd, &write_fds); |
| 546 | + FD_SET(write_fd, &except_fds); |
| 547 | + if (write_fd > maxfd) |
| 548 | + maxfd = write_fd; |
| 549 | + } |
| 550 | + if (read_fd >= 0) { |
| 551 | + FD_SET(read_fd, &read_fds); |
| 552 | + FD_SET(read_fd, &except_fds); |
| 553 | + if (read_fd > maxfd) |
| 554 | + maxfd = read_fd; |
| 555 | + } |
| 556 | + |
| 557 | + res = do_select(maxfd+1, &read_fds, &write_fds, &except_fds, &tv); |
| 558 | + if (res > 0) |
| 559 | + return 1; |
| 560 | + if (res < 0) { |
| 561 | + if (errno == EINTR || errno == EAGAIN) |
| 562 | + continue; /* Retry */ |
| 563 | + rprintf(FERROR, "Error awaiting fname converter: %s\n", strerror(errno)); |
| 564 | + exit_cleanup(RERR_FNAMECONV); |
| 565 | + } |
| 566 | + if (read_fd >= 0 && (FD_ISSET(read_fd, &read_fds) || FD_ISSET(read_fd, &except_fds))) |
| 567 | + return 1; |
| 568 | + if (write_fd >= 0 && (FD_ISSET(write_fd, &write_fds) || FD_ISSET(write_fd, &except_fds))) |
| 569 | + return 1; |
| 570 | + return 0; /* res == 0 and no FDs set, hence a timeout. */ |
| 571 | + } |
| 572 | +} |