time-based to count-based (keeping the newest 10 items).

backup-suffix files to be perishable.

send the excludes over the socket for a local copy.

for the --backup option and the --partial-dir option.

that we are sure to only apply the perishable filter modifier when
the receiving side is new enough to understand it.

that they don't stop a vanished directory from being removed.

rules applied to it as other newly-created directories when --perms
wasn't specified.

- Moved the FILECNT_LOOKAHEAD define into rsync.h.

when the sender gets an index of a file to send, we make sure to
send enough future file-list data relative to the new cur_flist
value before we send the data for the file transfer (ensuring that
the generator gets the data in a more timely manner), and (2) the
generator flushes the output socket after each file-list object
has completed its scan so that the sender knows in a more timely
manner that more list data is needed.

options we received over the socket.  (Thanks, Matt!)

a value that is relative to the cur_flist object.  This makes the
variable consistent with how the sender and the receiver use it.

over-the-wire value, making it consistent with the ndx arg that
is passed to decrement_active_files().

in incremental recurse mode -- it is enough to check for them
when changing from one file-list to another.

flist_for_ndx() routine needs to work when cur_flist is NULL.

- Changed increment_active_files() to call check_for_finished_files()
  and to avoid calling both io_flush() and read_msg_fd() in the same
  iteration of a loop (since the former may have called the latter).

sends, and finished hard-links into check_for_finished_files(), a new
function that takes the place of check_for_finished_hlinks().  This
lets us signal the sender more rapidly when a file-list is done (which
ensures that it sends us more work to do in a timely manner), and also
avoids two potential deadlocks in the old code.

  if the io_flush() call happened to read the last message from the
  receiver, causing the read_msg_fd() call to deadlock.
- Fixed an error-looping problem when the server-side receiver failed
  to send a message down the error-msg pipe:  we no longer try to send
  a new error about this new failure down the same failing pipe.
- Make sure that we stop any deferring of forwarded messages in the
  generator when we are exiting with an error.

by the stats.total_read value so that the generator can set its value
to that of the receiver.  This makes log_exit() log the right value
when we're on the server side.

explicit that it is best used with an empty destination hierarchy.

  temporarily set to -1.
- Got rid of the msg2genr message cache.

set to -1.

so that the delete code doesn't change the value.