make proto
This patch adds the ability to merge rules into your excludes/includes
-using a ". FILE" idiom. If you specify a name without slashes, that
-filename will be looked for in every subdirectory that rsync visits,
-and the rules found in that subdirectory's file will affect that dir
-and its subdirectories.
+using either "+m FILE" (for merged includes) or "-m FILE" (for merged
+excludes). It also lets you specify either "+p FILE" or "-p FILE" in
+order to specify a per-directory merge file -- one that will be looked
+for in every sub-directory that rsync visits, and the rules found in
+that subdirectory's file will affect that dir and (if desired) its
+subdirs.
For example:
- rsync -av --exclude='. .excl' from/ to
+ rsync -av --exclude='-p .excl' from/ to
The above will look for a file named ".excl" in every directory of the
hierarchy that rsync visits, and it will exclude (by default) names
this:
+ *.c
- . .excl2
- . ./.excl3
+ -p .excl2
+ -m .excl3
*.o
+ /foobar
-Then the file ".excl2" will also be read in the current dir, and all
-subdirs of the current dir. The file ".excl3" would just be read in
-for the current dir because its name contained a slash.
+Then the file ".excl2" will also be read in from the current dir and all
+its subdirs. The file ".excl3" would just be read in from the current
+dir. The exclusion of "foobar" will only happen in that .excl file's
+directory because the rule is anchored, so that's how you can make rules
+local instead of inherited.
..wayne..
---- exclude.c 16 May 2004 14:08:34 -0000 1.79
-+++ exclude.c 16 May 2004 22:04:31 -0000
-@@ -30,14 +30,54 @@ extern int verbose;
+--- orig/clientserver.c 2005-01-01 21:11:00
++++ clientserver.c 2004-08-10 15:44:15
+@@ -49,12 +49,14 @@ extern int no_detach;
+ extern int default_af_hint;
+ extern char *bind_address;
+ extern struct exclude_list_struct server_exclude_list;
+-extern char *exclude_path_prefix;
+ extern char *config_file;
+ extern char *files_from;
+
+ char *auth_user;
+
++/* Length of lp_path() string when in daemon mode & not chrooted, else 0. */
++unsigned int module_dirlen = 0;
++
+ /**
+ * Run a client connected to an rsyncd. The alternative to this
+ * function for remote-shell connections is do_cmd().
+@@ -304,26 +306,28 @@ static int rsync_module(int f_in, int f_
+ /* TODO: Perhaps take a list of gids, and make them into the
+ * supplementary groups. */
+
+- exclude_path_prefix = use_chroot? "" : lp_path(i);
+- if (*exclude_path_prefix == '/' && !exclude_path_prefix[1])
+- exclude_path_prefix = "";
++ if (use_chroot) {
++ module_dirlen = 0;
++ set_excludes_dir("/", 1);
++ } else {
++ module_dirlen = strlen(lp_path(i));
++ set_excludes_dir(lp_path(i), module_dirlen);
++ }
+
+ p = lp_include_from(i);
+ add_exclude_file(&server_exclude_list, p,
+- XFLG_FATAL_ERRORS | XFLG_DEF_INCLUDE);
++ XFLG_FATAL_ERRORS | XFLG_DEF_INCLUDE | XFLG_ABS_PATH);
+
+ p = lp_include(i);
+ add_exclude(&server_exclude_list, p,
+- XFLG_WORD_SPLIT | XFLG_DEF_INCLUDE);
++ XFLG_WORD_SPLIT | XFLG_DEF_INCLUDE | XFLG_ABS_PATH);
+
+ p = lp_exclude_from(i);
+ add_exclude_file(&server_exclude_list, p,
+- XFLG_FATAL_ERRORS);
++ XFLG_FATAL_ERRORS | XFLG_ABS_PATH);
+
+ p = lp_exclude(i);
+- add_exclude(&server_exclude_list, p, XFLG_WORD_SPLIT);
+-
+- exclude_path_prefix = NULL;
++ add_exclude(&server_exclude_list, p, XFLG_WORD_SPLIT | XFLG_ABS_PATH);
+
+ log_init();
+
+--- orig/exclude.c 2005-01-13 23:15:56
++++ exclude.c 2005-01-15 05:29:58
+@@ -30,13 +30,69 @@ extern int verbose;
extern int eol_nulls;
extern int list_only;
extern int recurse;
+extern int sanitize_paths;
extern char curr_dir[];
++extern unsigned int curr_dir_len;
++extern unsigned int module_dirlen;
--struct exclude_list_struct exclude_list = { 0, 0, "" };
+ struct exclude_list_struct exclude_list = { 0, 0, "" };
-struct exclude_list_struct local_exclude_list = { 0, 0, "per-dir .cvsignore " };
--struct exclude_list_struct server_exclude_list = { 0, 0, "server " };
-+struct exclude_list_struct exclude_list = { 0, 0, 0, "" };
-+struct exclude_list_struct server_exclude_list = { 0, 0, 0, "server " };
- char *exclude_path_prefix = NULL;
-
-+struct exclude_list_root {
+ struct exclude_list_struct server_exclude_list = { 0, 0, "server " };
+-char *exclude_path_prefix = NULL;
++
++struct mergelist_save_struct {
+ struct exclude_list_struct *array;
-+ int cnt;
-+} local_lists;
++ int count;
++};
++
++/* The dirbuf is set by push_local_excludes() to the current subdirectory
++ * relative to curr_dir that is being processed. The path always has a
++ * trailing slash appended, and the variable dirbuf_len contains the length
++ * of this path prefix. The path is always absolute. */
++static char dirbuf[MAXPATHLEN+1];
++static unsigned int dirbuf_len = 0;
++static int dirbuf_depth;
+
-+static char dirbuf[MAXPATHLEN];
-+static unsigned int dirbuf_offset = 0;
++/* This is True when we're scanning parent dirs for per-dir merge-files. */
++static BOOL parent_dirscan = False;
++
++/* This array contains a list of all the currently active per-dir merge
++ * files. This makes it easier to save the appropriate values when we
++ * "push" down into each subdirectory. */
++static struct exclude_struct **mergelist_parents;
++static int mergelist_cnt = 0;
++static int mergelist_size = 0;
+
+/* Each exclude_list_struct describes a singly-linked list by keeping track
+ * of both the head and tail pointers. The list is slightly unusual in that
+ * head -> Parent1 -> Parent2 -> NULL head -> L1 -> L2 -> P1 -> P2 -> NULL
+ * tail -> NULL tail ---------^
+ *
-+ * This means that anyone wanting to traverse the whole list to USE it just
++ * This means that anyone wanting to traverse the whole list to use it just
+ * needs to start at the head and use the "next" pointers until it goes
+ * NULL. To add new local content, we insert the item after the tail item
+ * and update the tail (obviously, if "tail" was NULL, we insert it at the
+ * the list for a new local dir, we just save off the exclude_list_struct
+ * values (so we can pop back to them later) and set the tail to NULL.
+ */
-+
+
/** Build an exclude structure given an exclude pattern. */
static void make_exclude(struct exclude_list_struct *listp, const char *pat,
- unsigned int pat_len, unsigned int mflags)
-@@ -46,6 +86,24 @@ static void make_exclude(struct exclude_
+@@ -46,23 +102,50 @@ static void make_exclude(struct exclude_
const char *cp;
unsigned int ex_len;
++ if (verbose > 2) {
++ rprintf(FINFO, "[%s] add_exclude(%.*s, %s%s%sclude)\n",
++ who_am_i(), (int)pat_len, pat, listp->debug_type,
++ mflags & MATCHFLG_MERGE_FILE ? "FILE " : "",
++ mflags & MATCHFLG_INCLUDE ? "in" : "ex");
++ }
++
+ if (mflags & MATCHFLG_MERGE_FILE) {
-+ struct exclude_struct *ex;
-+ /* If the local include file was already mentioned, don't
++ int i;
++ /* If the local merge file was already mentioned, don't
+ * add it again. */
-+ for (ex = listp->head; ex; ex = ex->next) {
-+ if (ex->match_flags & MATCHFLG_MERGE_FILE
-+ && strlen(ex->pattern) == pat_len
-+ && strncmp(ex->pattern, pat, pat_len) == 0)
++ for (i = 0; i < mergelist_cnt; i++) {
++ struct exclude_struct *ex = mergelist_parents[i];
++ if (strlen(ex->pattern) == pat_len
++ && memcmp(ex->pattern, pat, pat_len) == 0)
+ return;
+ }
+ if ((pat_len == 10 || (pat_len > 10 && pat[pat_len-11] == '/'))
ret = new(struct exclude_struct);
if (!ret)
out_of_memory("make_exclude");
-@@ -81,14 +139,35 @@ static void make_exclude(struct exclude_
+
+ memset(ret, 0, sizeof ret[0]);
+
+- if (exclude_path_prefix)
+- mflags |= MATCHFLG_ABS_PATH;
+- if (exclude_path_prefix && *pat == '/')
+- ex_len = strlen(exclude_path_prefix);
+- else
++ if (mflags & MATCHFLG_ABS_PATH) {
++ if (*pat != '/') {
++ mflags &= ~MATCHFLG_ABS_PATH;
++ ex_len = 0;
++ } else
++ ex_len = dirbuf_len - module_dirlen - 1;
++ } else
+ ex_len = 0;
+ ret->pattern = new_array(char, ex_len + pat_len + 1);
+ if (!ret->pattern)
+ out_of_memory("make_exclude");
+ if (ex_len)
+- memcpy(ret->pattern, exclude_path_prefix, ex_len);
++ memcpy(ret->pattern, dirbuf + module_dirlen, ex_len);
+ strlcpy(ret->pattern + ex_len, pat, pat_len + 1);
+ pat_len += ex_len;
+
+@@ -81,14 +164,40 @@ static void make_exclude(struct exclude_
mflags |= MATCHFLG_DIRECTORY;
}
- for (cp = ret->pattern; (cp = strchr(cp, '/')) != NULL; cp++)
- ret->slash_cnt++;
+ if (mflags & MATCHFLG_MERGE_FILE) {
-+ struct exclude_list_struct *lp = local_lists.array;
-+ int ndx = local_lists.cnt++;
-+ local_lists.array = realloc_array(local_lists.array,
-+ struct exclude_list_struct, local_lists.cnt);
-+ if (!local_lists.array)
++ struct exclude_list_struct *lp
++ = new_array(struct exclude_list_struct, 1);
++ if (!lp)
+ out_of_memory("make_exclude");
-+ /* If "listp" was pointing inside the memory we just
-+ * reallocated, update it. */
-+ if (ndx && listp >= lp && listp < lp + ndx)
-+ listp = &local_lists.array[listp - lp];
-+ lp = &local_lists.array[ndx];
+ lp->head = lp->tail = NULL;
-+ lp->parent = ret;
-+ if (asprintf(&lp->debug_type, "per-dir %s ", ret->pattern) < 0)
++ if ((cp = strrchr(ret->pattern, '/')) != NULL)
++ cp++;
++ else
++ cp = ret->pattern;
++ if (asprintf(&lp->debug_type, "per-dir %s ", cp) < 0)
+ out_of_memory("make_exclude");
-+ ret->u.array_index = ndx;
++ ret->u.mergelist = lp;
++ if (mergelist_cnt == mergelist_size) {
++ mergelist_size += 5;
++ mergelist_parents = realloc_array(mergelist_parents,
++ struct exclude_struct *,
++ mergelist_size);
++ if (!mergelist_parents)
++ out_of_memory("make_exclude");
++ }
++ mergelist_parents[mergelist_cnt++] = ret;
+ } else {
+ for (cp = ret->pattern; (cp = strchr(cp, '/')) != NULL; cp++)
+ ret->u.slash_cnt++;
listp->tail->next = ret;
listp->tail = ret;
}
-@@ -100,18 +179,90 @@ static void free_exclude(struct exclude_
+@@ -96,22 +205,267 @@ static void make_exclude(struct exclude_
+
+ static void free_exclude(struct exclude_struct *ex)
+ {
++ if (ex->match_flags & MATCHFLG_MERGE_FILE) {
++ free(ex->u.mergelist->debug_type);
++ free(ex->u.mergelist);
++ }
+ free(ex->pattern);
free(ex);
}
--void free_exclude_list(struct exclude_list_struct *listp)
-+static void free_exclude_list(struct exclude_list_struct *listp)
+-void clear_exclude_list(struct exclude_list_struct *listp)
++static void clear_exclude_list(struct exclude_list_struct *listp)
{
- struct exclude_struct *ent, *next;
-
+ struct exclude_struct *ent, *next;
+ /* Truncate any inherited items from the local list. */
+ listp->tail->next = NULL;
++ /* Now free everything that is left. */
+ for (ent = listp->head; ent; ent = next) {
+ next = ent->next;
+ free_exclude(ent);
listp->head = listp->tail = NULL;
}
-+void *push_local_excludes(char *fname, unsigned int offset)
++/* This returns an expanded (absolute) filename for the merge-file name if
++ * the name has any slashes in it OR if the parent_dirscan var is True;
++ * otherwise it returns the original merge_file name. If the len_ptr value
++ * is non-NULL the merge_file name is limited by the referenced length
++ * value and will be updated with the length of the resulting name. We
++ * always return a name that is null terminated, even if the merge_file
++ * name was not. */
++static char *parse_merge_name(const char *merge_file, unsigned int *len_ptr,
++ unsigned int prefix_skip)
++{
++ static char buf[MAXPATHLEN];
++ char *fn, tmpbuf[MAXPATHLEN];
++ unsigned int fn_len;
++
++ if (!parent_dirscan && *merge_file != '/') {
++ /* Return the name unchanged it doesn't have any slashes. */
++ if (len_ptr) {
++ const char *p = merge_file + *len_ptr;
++ while (--p > merge_file && *p != '/') {}
++ if (p == merge_file) {
++ strlcpy(buf, merge_file, *len_ptr + 1);
++ return buf;
++ }
++ } else if (strchr(merge_file, '/') == NULL)
++ return (char *)merge_file;
++ }
++
++ fn = *merge_file == '/' ? buf : tmpbuf;
++ if (sanitize_paths) {
++ const char *r = prefix_skip ? "/" : NULL;
++ /* null-terminate the name if it isn't already */
++ if (len_ptr && merge_file[*len_ptr]) {
++ char *to = fn == buf ? tmpbuf : buf;
++ strlcpy(to, merge_file, *len_ptr + 1);
++ merge_file = to;
++ }
++ if (!sanitize_path(fn, merge_file, r, dirbuf_depth)) {
++ rprintf(FERROR, "merge-file name overflows: %s\n",
++ merge_file);
++ return NULL;
++ }
++ } else {
++ strlcpy(fn, merge_file, len_ptr ? *len_ptr + 1 : MAXPATHLEN);
++ clean_fname(fn, 1);
++ }
++
++ fn_len = strlen(fn);
++ if (fn == buf)
++ goto done;
++
++ if (dirbuf_len + fn_len >= MAXPATHLEN) {
++ rprintf(FERROR, "merge-file name overflows: %s\n", fn);
++ return NULL;
++ }
++ memcpy(buf, dirbuf + prefix_skip, dirbuf_len - prefix_skip);
++ memcpy(buf + dirbuf_len - prefix_skip, fn, fn_len + 1);
++ fn_len = clean_fname(buf, 1);
++
++ done:
++ if (len_ptr)
++ *len_ptr = fn_len;
++ return buf;
++}
++
++/* Sets the dirbuf and dirbuf_len values. */
++void set_excludes_dir(const char *dir, unsigned int dirlen)
+{
++ unsigned int len;
++ if (*dir != '/') {
++ memcpy(dirbuf, curr_dir, curr_dir_len);
++ dirbuf[curr_dir_len] = '/';
++ len = curr_dir_len + 1;
++ if (len + dirlen >= MAXPATHLEN)
++ dirlen = 0;
++ } else
++ len = 0;
++ memcpy(dirbuf + len, dir, dirlen);
++ dirbuf[dirlen + len] = '\0';
++ dirbuf_len = clean_fname(dirbuf, 1);
++ if (dirbuf_len > 1 && dirbuf[dirbuf_len-1] == '.'
++ && dirbuf[dirbuf_len-2] == '/')
++ dirbuf_len -= 2;
++ dirbuf[dirbuf_len++] = '/';
++ dirbuf[dirbuf_len] = '\0';
++ if (sanitize_paths)
++ dirbuf_depth = count_dir_elements(dirbuf + module_dirlen);
++}
++
++/* This routine takes a per-dir merge-file entry and finishes its setup.
++ * If the name has a path portion then we check to see if it refers to a
++ * parent directory of the first transfer dir. If it does, we scan all the
++ * dirs from that point through the parent dir of the transfer dir looking
++ * for the per-dir merge-file in each one. */
++static BOOL setup_merge_file(struct exclude_struct *ex,
++ struct exclude_list_struct *lp, int flags)
++{
++ char buf[MAXPATHLEN];
++ char *x, *y, *pat = ex->pattern;
++ unsigned int len;
++
++ if (!(x = parse_merge_name(pat, NULL, 0)) || *x != '/')
++ return 0;
++
++ y = strrchr(x, '/');
++ *y = '\0';
++ ex->pattern = strdup(y+1);
++ if (!*x)
++ x = "/";
++ if (*x == '/')
++ strlcpy(buf, x, MAXPATHLEN);
++ else
++ pathjoin(buf, MAXPATHLEN, dirbuf, x);
++
++ len = clean_fname(buf, 1);
++ if (len != 1 && len < MAXPATHLEN-1) {
++ buf[len++] = '/';
++ buf[len] = '\0';
++ }
++ /* This ensures that the specified dir is a parent of the transfer. */
++ for (x = buf, y = dirbuf; *x && *x == *y; x++, y++) {}
++ if (*x)
++ y += strlen(y); /* nope -- skip the scan */
++
++ parent_dirscan = True;
++ while (*y) {
++ char save[MAXPATHLEN];
++ strlcpy(save, y, MAXPATHLEN);
++ *y = '\0';
++ dirbuf_len = y - dirbuf;
++ strlcpy(x, ex->pattern, MAXPATHLEN - (x - buf));
++ add_exclude_file(lp, buf, flags | XFLG_ABS_PATH);
++ if (ex->match_flags & MATCHFLG_CVSIGNORE)
++ lp->head = NULL; /* CVS doesn't inherit rules. */
++ lp->tail = NULL;
++ strlcpy(y, save, MAXPATHLEN);
++ while ((*x++ = *y++) != '/') {}
++ }
++ parent_dirscan = False;
++ free(pat);
++ return 1;
++}
++
++/* Each time rsync changes to a new directory it call this function to
++ * handle all the per-dir merge-files. The "dir" value is the current path
++ * relative to curr_dir (which might not be null-terminated). We copy it
++ * into dirbuf so that we can easily append a file name on the end. */
++void *push_local_excludes(const char *dir, unsigned int dirlen)
++{
++ struct mergelist_save_struct *push;
++ struct exclude_list_struct *ap;
+ int i;
-+ struct exclude_list_root *push = new_array(struct exclude_list_root, 1);
+
-+ if (!push)
++ set_excludes_dir(dir, dirlen);
++
++ if (!(push = new_array(struct mergelist_save_struct, 1)))
+ out_of_memory("push_local_excludes");
+
-+ push->cnt = local_lists.cnt;
-+ push->array = new_array(struct exclude_list_struct, local_lists.cnt);
++ push->count = mergelist_cnt;
++ push->array = new_array(struct exclude_list_struct, mergelist_cnt);
+ if (!push->array)
+ out_of_memory("push_local_excludes");
+
-+ memcpy(push->array, local_lists.array,
-+ sizeof (struct exclude_list_struct) * local_lists.cnt);
-+
-+ /* Make it easy to construct the full path for a merge-file that was
-+ * specified with a relative path by saving off the current dir. */
-+ memcpy(dirbuf, fname, offset);
-+ dirbuf_offset = offset;
++ for (i = 0, ap = push->array; i < mergelist_cnt; i++) {
++ memcpy(ap++, mergelist_parents[i]->u.mergelist,
++ sizeof (struct exclude_list_struct));
++ }
+
-+ for (i = 0; i < local_lists.cnt; i++) {
-+ struct exclude_list_struct *listp = &local_lists.array[i];
-+ char *file = listp->parent->pattern;
++ /* Note: add_exclude_file() might increase mergelist_cnt, so keep
++ * this loop separate from the above loop. */
++ for (i = 0; i < mergelist_cnt; i++) {
++ struct exclude_struct *ex = mergelist_parents[i];
++ struct exclude_list_struct *lp = ex->u.mergelist;
+ int flags;
+
+ if (verbose > 2) {
+ rprintf(FINFO, "[%s] pushing %sexclude list\n",
-+ who_am_i(), listp->debug_type);
++ who_am_i(), lp->debug_type);
+ }
-+ if (listp->parent->match_flags & MATCHFLG_CVSIGNORE) {
-+ listp->head = NULL; /* Subdirs don't inherit rules. */
++
++ if (ex->match_flags & MATCHFLG_CVSIGNORE) {
++ lp->head = NULL; /* CVS doesn't inherit rules. */
+ flags = XFLG_WORD_SPLIT | XFLG_WORDS_ONLY;
+ } else {
-+ flags = listp->parent->match_flags & MATCHFLG_INCLUDE
++ flags = ex->match_flags & MATCHFLG_INCLUDE
+ ? XFLG_DEF_INCLUDE : 0;
+ }
-+ listp->tail = NULL; /* Signals no local content. */
-+ if (strlcpy(fname + offset, file, MAXPATHLEN - offset)
-+ < MAXPATHLEN - offset)
-+ add_exclude_file(listp, fname, flags);
++ lp->tail = NULL; /* Switch any local rules to inherited. */
++
++ if (ex->match_flags & MATCHFLG_FINISH_SETUP) {
++ ex->match_flags &= ~MATCHFLG_FINISH_SETUP;
++ if (setup_merge_file(ex, lp, flags))
++ set_excludes_dir(dir, dirlen);
++ }
++
++ if (strlcpy(dirbuf + dirbuf_len, ex->pattern,
++ MAXPATHLEN - dirbuf_len) < MAXPATHLEN - dirbuf_len)
++ add_exclude_file(lp, dirbuf, flags | XFLG_ABS_PATH);
+ else {
+ io_error |= IOERR_GENERAL;
+ rprintf(FINFO,
+ "cannot add local excludes in long-named directory %s\n",
-+ full_fname(fname));
++ full_fname(dirbuf));
+ }
++ dirbuf[dirbuf_len] = '\0';
+ }
+
+ return (void*)push;
+
+void pop_local_excludes(void *mem)
+{
++ struct mergelist_save_struct *pop = (struct mergelist_save_struct*)mem;
++ struct exclude_list_struct *ap;
+ int i;
+
-+ for (i = 0; i < local_lists.cnt; i++) {
-+ struct exclude_list_struct *listp = &local_lists.array[i];
++ for (i = mergelist_cnt; i-- > 0; ) {
++ struct exclude_struct *ex = mergelist_parents[i];
++ struct exclude_list_struct *lp = ex->u.mergelist;
++
+ if (verbose > 2) {
+ rprintf(FINFO, "[%s] popping %sexclude list\n",
-+ who_am_i(), listp->debug_type);
++ who_am_i(), lp->debug_type);
+ }
-+ free_exclude_list(listp);
++
++ clear_exclude_list(lp);
++ }
++
++ mergelist_cnt = pop->count;
++ for (i = 0, ap = pop->array; i < mergelist_cnt; i++) {
++ memcpy(mergelist_parents[i]->u.mergelist, ap++,
++ sizeof (struct exclude_list_struct));
+ }
-+ free(local_lists.array);
-+ local_lists = *(struct exclude_list_root*)mem;
-+ free(mem);
++
++ free(pop->array);
++ free(pop);
+}
+
static int check_one_exclude(char *name, struct exclude_struct *ex,
int name_is_dir)
{
-@@ -122,7 +273,7 @@ static int check_one_exclude(char *name,
+@@ -125,13 +479,14 @@ static int check_one_exclude(char *name,
/* If the pattern does not have any slashes AND it does not have
* a "**" (which could match a slash), then we just match the
* name portion of the path. */
if ((p = strrchr(name,'/')) != NULL)
name = p+1;
}
-@@ -148,9 +299,9 @@ static int check_one_exclude(char *name,
+ else if (ex->match_flags & MATCHFLG_ABS_PATH && *name != '/'
+- && curr_dir[1]) {
+- pathjoin(full_name, sizeof full_name, curr_dir + 1, name);
++ && curr_dir_len > module_dirlen + 1) {
++ pathjoin(full_name, sizeof full_name,
++ curr_dir + module_dirlen + 1, name);
+ name = full_name;
+ }
+
+@@ -148,9 +503,9 @@ static int check_one_exclude(char *name,
if (ex->match_flags & MATCHFLG_WILD) {
/* A non-anchored match with an infix slash and no "**"
* needs to match the last slash_cnt+1 name elements. */
for (p = name + strlen(name) - 1; p >= name; p--) {
if (*p == '/' && !--cnt)
break;
-@@ -221,6 +372,14 @@ int check_exclude(struct exclude_list_st
+@@ -221,6 +576,13 @@ int check_exclude(struct exclude_list_st
struct exclude_struct *ent;
for (ent = listp->head; ent; ent = ent->next) {
+ if (ent->match_flags & MATCHFLG_MERGE_FILE) {
-+ struct exclude_list_struct *lp
-+ = &local_lists.array[ent->u.array_index];
-+ int rc = check_exclude(lp, name, name_is_dir);
++ int rc = check_exclude(ent->u.mergelist, name,
++ name_is_dir);
+ if (rc)
+ return rc;
+ continue;
if (check_one_exclude(name, ent, name_is_dir)) {
report_exclude_result(name, ent, name_is_dir,
listp->debug_type);
-@@ -254,11 +413,16 @@ static const char *get_exclude_tok(const
+@@ -254,12 +616,28 @@ static const char *get_exclude_tok(const
p = (const char *)s;
}
- /* Is this a '+' or '-' followed by a space (not whitespace)? */
-+ /* Is this a +/-/. followed by a space (not whitespace)? */
- if (!(xflags & XFLG_WORDS_ONLY)
+- if (!(xflags & XFLG_WORDS_ONLY)
- && (*s == '-' || *s == '+') && s[1] == ' ') {
-+ && (*s == '-' || *s == '+' || *s == '.') && s[1] == ' ') {
++ /* Check for a leading '+' or '-'. */
++ if (!(xflags & XFLG_WORDS_ONLY) && (*s == '-' || *s == '+')) {
if (*s == '+')
mflags |= MATCHFLG_INCLUDE;
-+ else if (*s == '.') {
-+ mflags |= MATCHFLG_MERGE_FILE;
-+ if (xflags & XFLG_DEF_INCLUDE)
-+ mflags |= MATCHFLG_INCLUDE;
+- s += 2;
++ while (*++s != ' ') {
++ switch (*s) {
++ case 'p':
++ mflags |= MATCHFLG_MERGE_FILE
++ | MATCHFLG_PERDIR_MERGE
++ | MATCHFLG_FINISH_SETUP;
++ break;
++ case 'm':
++ mflags |= MATCHFLG_MERGE_FILE;
++ break;
++ default:
++ rprintf(FERROR,
++ "invalid include/exclude option after %c: %c\n",
++ *p, *s);
++ exit_cleanup(RERR_SYNTAX);
++ }
+ }
- s += 2;
++ s++;
} else if (xflags & XFLG_DEF_INCLUDE)
mflags |= MATCHFLG_INCLUDE;
-@@ -307,11 +471,42 @@ void add_exclude(struct exclude_list_str
+ if (xflags & XFLG_DIRECTORY)
+@@ -276,6 +654,8 @@ static const char *get_exclude_tok(const
+
+ if (*p == '!' && len == 1)
+ mflags |= MATCHFLG_CLEAR_LIST;
++ if (xflags & XFLG_ABS_PATH)
++ mflags |= MATCHFLG_ABS_PATH;
+
+ *len_ptr = len;
+ *flag_ptr = mflags;
+@@ -287,7 +667,7 @@ void add_exclude(struct exclude_list_str
+ int xflags)
+ {
+ unsigned int pat_len, mflags;
+- const char *cp;
++ const char *cp, *p;
+
+ if (!pattern)
+ return;
+@@ -295,9 +675,15 @@ void add_exclude(struct exclude_list_str
+ cp = pattern;
+ pat_len = 0;
+ while (1) {
++ /* Remember that the returned string is NOT '\0' terminated! */
+ cp = get_exclude_tok(cp + pat_len, &pat_len, &mflags, xflags);
+ if (!pat_len)
+ break;
++ if (pat_len >= MAXPATHLEN) {
++ rprintf(FERROR, "discarding over-long exclude: %s\n",
++ cp);
++ continue;
++ }
+
+ if (mflags & MATCHFLG_CLEAR_LIST) {
+ if (verbose > 2) {
+@@ -309,13 +695,24 @@ void add_exclude(struct exclude_list_str
continue;
}
+- make_exclude(listp, cp, pat_len, mflags);
+-
+- if (verbose > 2) {
+- rprintf(FINFO, "[%s] add_exclude(%.*s, %s%sclude)\n",
+- who_am_i(), (int)pat_len, cp, listp->debug_type,
+- mflags & MATCHFLG_INCLUDE ? "in" : "ex");
+ if (mflags & MATCHFLG_MERGE_FILE) {
-+ char name[MAXPATHLEN];
-+ if (pat_len >= sizeof name) {
-+ rprintf(FERROR,
-+ "merge filename too long: %s\n", cp);
-+ continue;
-+ }
-+ strlcpy(name, cp, pat_len+1);
-+ if (strchr(name, '/') != NULL) {
-+ if (sanitize_paths)
-+ sanitize_path(name, curr_dir);
-+ if (*name == '/')
-+ cp = name;
-+ else {
-+ if (strlcpy(dirbuf + dirbuf_offset,
-+ name, MAXPATHLEN - dirbuf_offset)
-+ >= MAXPATHLEN - dirbuf_offset) {
-+ rprintf(FERROR,
-+ "merge filename too long: %s...\n",
-+ dirbuf);
++ unsigned int len = pat_len;
++ if (mflags & MATCHFLG_PERDIR_MERGE) {
++ if (parent_dirscan) {
++ if (!(p = parse_merge_name(cp, &len, module_dirlen)))
+ continue;
-+ }
-+ cp = dirbuf;
++ make_exclude(listp, p, len, mflags);
++ continue;
+ }
-+ add_exclude_file(listp, cp,
-+ xflags | XFLG_FATAL_ERRORS);
++ } else {
++ if (!(p = parse_merge_name(cp, &len, 0)))
++ continue;
++ add_exclude_file(listp, p, xflags | XFLG_FATAL_ERRORS);
+ continue;
+ }
-+ }
+ }
+
- make_exclude(listp, cp, pat_len, mflags);
++ make_exclude(listp, cp, pat_len, mflags);
+ }
+ }
- if (verbose > 2) {
-- rprintf(FINFO, "[%s] add_exclude(%.*s, %s%sclude)\n",
-+ rprintf(FINFO, "[%s] add_exclude(%.*s, %s%s%sclude)\n",
- who_am_i(), pat_len, cp, listp->debug_type,
-+ mflags & MATCHFLG_MERGE_FILE ? "FILE " : "",
- mflags & MATCHFLG_INCLUDE ? "in" : "ex");
+@@ -324,7 +721,7 @@ void add_exclude_file(struct exclude_lis
+ int xflags)
+ {
+ FILE *fp;
+- char line[MAXPATHLEN+3]; /* Room for "x " prefix and trailing slash. */
++ char line[MAXPATHLEN+4]; /* Room for prefix chars and trailing slash. */
+ char *eob = line + sizeof line - 1;
+ int word_split = xflags & XFLG_WORD_SPLIT;
+
+@@ -345,6 +742,12 @@ void add_exclude_file(struct exclude_lis
}
+ return;
}
-@@ -403,7 +598,11 @@ void send_exclude_list(int f)
- if (ent->match_flags & MATCHFLG_INCLUDE) {
++ dirbuf[dirbuf_len] = '\0';
++
++ if (verbose > 2) {
++ rprintf(FINFO, "[%s] add_exclude_file(%s,%d)\n",
++ who_am_i(), fname, xflags);
++ }
+
+ while (1) {
+ char *s = line;
+@@ -402,7 +805,20 @@ void send_exclude_list(int f)
+ p[l] = '\0';
+ }
+
+- if (ent->match_flags & MATCHFLG_INCLUDE) {
++ if (ent->match_flags & MATCHFLG_MERGE_FILE) {
++ char buf[32], *op = buf;
++ if (ent->match_flags & MATCHFLG_INCLUDE)
++ *op++ = '+';
++ else
++ *op++ = '-';
++ if (ent->match_flags & MATCHFLG_PERDIR_MERGE)
++ *op++ = 'p';
++ else
++ *op++ = 'm';
++ *op++ = ' ';
++ write_int(f, l + (op - buf));
++ write_buf(f, buf, op - buf);
++ } else if (ent->match_flags & MATCHFLG_INCLUDE) {
write_int(f, l + 2);
write_buf(f, "+ ", 2);
-- } else if ((*p == '-' || *p == '+') && p[1] == ' ') {
-+ } else if (ent->match_flags & MATCHFLG_MERGE_FILE) {
-+ write_int(f, l + 2);
-+ write_buf(f, ". ", 2);
-+ } else if ((*p == '-' || *p == '+' || *p == '.')
-+ && p[1] == ' ') {
- write_int(f, l + 2);
- write_buf(f, "- ", 2);
- } else
-@@ -444,6 +643,7 @@ void add_cvs_excludes(void)
+ } else if (*p == '-' || *p == '+') {
+@@ -419,7 +835,7 @@ void send_exclude_list(int f)
+
+ void recv_exclude_list(int f)
+ {
+- char line[MAXPATHLEN+3]; /* Room for "x " prefix and trailing slash. */
++ char line[MAXPATHLEN+4]; /* Room for prefix and trailing slash. */
+ unsigned int l;
+
+ while ((l = read_int(f)) != 0) {
+@@ -446,6 +862,7 @@ void add_cvs_excludes(void)
char fname[MAXPATHLEN];
char *p;
-+ add_exclude(&exclude_list, ". .cvsignore", 0);
++ add_exclude(&exclude_list, "-p .cvsignore", 0);
add_exclude(&exclude_list, default_cvsignore,
XFLG_WORD_SPLIT | XFLG_WORDS_ONLY);
---- flist.c 15 May 2004 19:31:10 -0000 1.223
-+++ flist.c 16 May 2004 22:04:31 -0000
-@@ -39,8 +39,6 @@ extern int module_id;
+--- orig/flist.c 2005-01-01 21:11:00
++++ flist.c 2004-08-12 18:59:28
+@@ -40,10 +40,9 @@ extern int module_id;
extern int ignore_errors;
extern int numeric_ids;
-
extern int recurse;
extern char curr_dir[MAXPATHLEN];
++extern unsigned int curr_dir_len;
extern char *files_from;
-@@ -65,7 +63,6 @@ extern int write_batch;
+ extern int filesfrom_fd;
+
+@@ -67,7 +66,6 @@ extern int list_only;
extern struct exclude_list_struct exclude_list;
extern struct exclude_list_struct server_exclude_list;
int io_error;
-@@ -210,8 +207,6 @@ int link_stat(const char *path, STRUCT_S
+@@ -223,8 +221,6 @@ int link_stat(const char *path, STRUCT_S
*/
static int check_exclude_file(char *fname, int is_dir, int exclude_level)
{
#if 0 /* This currently never happens, so avoid a useless compare. */
if (exclude_level == NO_EXCLUDES)
return 0;
-@@ -233,10 +228,7 @@ static int check_exclude_file(char *fnam
+@@ -246,10 +242,7 @@ static int check_exclude_file(char *fnam
if (exclude_level != ALL_EXCLUDES)
return 0;
if (exclude_list.head
return 1;
return 0;
}
-@@ -946,15 +938,7 @@ void send_file_name(int f, struct file_l
+@@ -983,15 +976,7 @@ void send_file_name(int f, struct file_l
if (recursive && S_ISDIR(file->mode)
&& !(file->flags & FLAG_MOUNT_POINT)) {
- rprintf(FINFO, "[%s] popping %sexclude list\n",
- who_am_i(), local_exclude_list.debug_type);
- }
-- free_exclude_list(&local_exclude_list);
+- clear_exclude_list(&local_exclude_list);
- local_exclude_list = last_list;
}
}
-@@ -965,6 +949,7 @@ static void send_directory(int f, struct
+@@ -1002,6 +987,7 @@ static void send_directory(int f, struct
struct dirent *di;
char fname[MAXPATHLEN];
unsigned int offset;
char *p;
d = opendir(dir);
-@@ -988,18 +973,7 @@ static void send_directory(int f, struct
+@@ -1025,18 +1011,7 @@ static void send_directory(int f, struct
offset++;
}
for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) {
char *dname = d_name(di);
-@@ -1019,6 +993,8 @@ static void send_directory(int f, struct
- io_error |= IOERR_GENERAL;
+@@ -1057,6 +1032,8 @@ static void send_directory(int f, struct
rsyserr(FERROR, errno, "readdir(%s)", dir);
}
-+
-+ pop_local_excludes(save_excludes);
++ pop_local_excludes(save_excludes);
++
closedir(d);
}
---- rsync.h 16 May 2004 07:28:24 -0000 1.204
-+++ rsync.h 16 May 2004 22:04:33 -0000
-@@ -496,16 +496,21 @@ struct map_struct {
+
+@@ -1076,6 +1053,7 @@ struct file_list *send_file_list(int f,
+ char *p, *dir, olddir[sizeof curr_dir];
+ char lastpath[MAXPATHLEN] = "";
+ struct file_list *flist;
++ BOOL need_first_push = True;
+ int64 start_write;
+ int use_ff_fd = 0;
+
+@@ -1096,6 +1074,10 @@ struct file_list *send_file_list(int f,
+ exit_cleanup(RERR_FILESELECT);
+ }
+ use_ff_fd = 1;
++ if (curr_dir_len < MAXPATHLEN - 1) {
++ push_local_excludes(curr_dir, curr_dir_len);
++ need_first_push = False;
++ }
+ }
+ }
+
+@@ -1126,6 +1108,15 @@ struct file_list *send_file_list(int f,
+ }
+ }
+
++ if (need_first_push) {
++ if ((p = strrchr(fname, '/')) != NULL) {
++ if (*++p && strcmp(p, ".") != 0)
++ push_local_excludes(fname, p - fname);
++ } else if (strcmp(fname, ".") != 0)
++ push_local_excludes(fname, 0);
++ need_first_push = False;
++ }
++
+ if (link_stat(fname, &st, keep_dirlinks) != 0) {
+ if (f != -1) {
+ io_error |= IOERR_GENERAL;
+--- orig/options.c 2005-01-15 04:40:15
++++ options.c 2005-01-13 23:52:00
+@@ -296,6 +296,7 @@ void usage(enum logcode F)
+ rprintf(F," --include=PATTERN don't exclude files matching PATTERN\n");
+ rprintf(F," --include-from=FILE don't exclude patterns listed in FILE\n");
+ rprintf(F," --files-from=FILE read FILE for list of source-file names\n");
++ rprintf(F," -E same as --exclude='-p /.rsync-excludes'\n");
+ rprintf(F," -0, --from0 all *-from file lists are delimited by nulls\n");
+ rprintf(F," --version print version number\n");
+ rprintf(F," --port=PORT specify double-colon alternate port number\n");
+@@ -393,6 +394,7 @@ static struct poptOption long_options[]
+ {"ignore-errors", 0, POPT_ARG_NONE, &ignore_errors, 0, 0, 0 },
+ {"blocking-io", 0, POPT_ARG_VAL, &blocking_io, 1, 0, 0 },
+ {"no-blocking-io", 0, POPT_ARG_VAL, &blocking_io, 0, 0, 0 },
++ {0, 'E', POPT_ARG_NONE, 0, 'E', 0, 0 },
+ {0, 'P', POPT_ARG_NONE, 0, 'P', 0, 0 },
+ {"port", 0, POPT_ARG_INT, &rsync_port, 0, 0, 0 },
+ {"log-format", 0, POPT_ARG_STRING, &log_format, 0, 0, 0 },
+@@ -668,6 +670,11 @@ int parse_arguments(int *argc, const cha
+ am_sender = 1;
+ break;
+
++ case 'E':
++ add_exclude(&exclude_list,
++ "-p /.rsync-excludes", 0);
++ break;
++
+ case 'P':
+ do_progress = 1;
+ keep_partial = 1;
+--- orig/rsync.h 2005-01-10 00:21:12
++++ rsync.h 2004-09-22 08:48:53
+@@ -111,6 +111,7 @@
+ #define XFLG_WORDS_ONLY (1<<2)
+ #define XFLG_WORD_SPLIT (1<<3)
+ #define XFLG_DIRECTORY (1<<4)
++#define XFLG_ABS_PATH (1<<5)
+
+ #define PERMS_REPORT (1<<0)
+ #define PERMS_SKIP_MTIME (1<<1)
+@@ -510,11 +511,18 @@ struct map_struct {
#define MATCHFLG_INCLUDE (1<<4) /* this is an include, not an exclude */
#define MATCHFLG_DIRECTORY (1<<5) /* this matches only directories */
#define MATCHFLG_CLEAR_LIST (1<<6) /* this item is the "!" token */
+#define MATCHFLG_MERGE_FILE (1<<7) /* specifies a file to merge */
+#define MATCHFLG_CVSIGNORE (1<<8) /* parse this as a .cvsignore file */
++#define MATCHFLG_PERDIR_MERGE (1<<9) /* merge-file is searched per-dir */
++#define MATCHFLG_FINISH_SETUP (1<<10)/* per-dir merge file needs setup */
struct exclude_struct {
struct exclude_struct *next;
char *pattern;
- int slash_cnt;
+ union {
+ int slash_cnt;
-+ int array_index;
++ struct exclude_list_struct *mergelist;
+ } u;
};
struct exclude_list_struct {
-- struct exclude_struct *head;
-- struct exclude_struct *tail;
-+ struct exclude_struct *head, *tail;
-+ struct exclude_struct *parent;
- char *debug_type;
- };
+--- orig/rsync.yo 2005-01-15 04:36:32
++++ rsync.yo 2005-01-14 00:10:38
+@@ -366,6 +366,7 @@ verb(
+ --include=PATTERN don't exclude files matching PATTERN
+ --include-from=FILE don't exclude patterns listed in FILE
+ --files-from=FILE read FILE for list of source-file names
++ -E same as --exclude='-p /.rsync-excludes'
+ -0 --from0 all file lists are delimited by nulls
+ --version print version number
+ --port=PORT specify double-colon alternate port number
+@@ -1114,24 +1115,32 @@ The exclude and include patterns specifi
+ selection of which files to transfer and which files to skip.
---- rsync.yo 7 May 2004 00:18:37 -0000 1.169
-+++ rsync.yo 16 May 2004 22:04:33 -0000
-@@ -1075,6 +1075,72 @@ itemize(
- it would be excluded by the "*")
- )
+ Rsync builds an ordered list of include/exclude options as specified on
+-the command line. Rsync checks each file and directory
+-name against each exclude/include pattern in turn. The first matching
++the command line.
++It can also be told to check for include/exclude options in each
++directory that rsync visits during the transfer (see the section on
++MERGED EXCLUDE FILES for the details on these per-directory exclude
++files).
++
++As the list of files/directories to transfer is built, rsync checks each
++name against every exclude/include pattern in turn. The first matching
+ pattern is acted on. If it is an exclude pattern, then that file is
+ skipped. If it is an include pattern then that filename is not
+ skipped. If no matching include/exclude pattern is found then the
+ filename is not skipped.
+
+-The filenames matched against the exclude/include patterns are relative
+-to the "root of the transfer". If you think of the transfer as a
+-subtree of names that are being sent from sender to receiver, the root
+-is where the tree starts to be duplicated in the destination directory.
+-This root governs where patterns that start with a / match (see below).
++The global include/exclude rules are anchored at the "root of the
++transfer" (as opposed to per-directory rules, which are anchored at
++the merge-file's directory). If you think of the transfer as a
++subtree of names that are being sent from sender to receiver, the
++transfer-root is where the tree starts to be duplicated in the
++destination directory. This root governs where patterns that start
++with a / match (as described in the list on pattern forms below).
+
+ Because the matching is relative to the transfer-root, changing the
+ trailing slash on a source path or changing your use of the --relative
+ option affects the path you need to use in your matching (in addition to
+ changing how much of the file tree is duplicated on the destination
+-system). The following examples demonstrate this.
++host). The following examples demonstrate this.
-+manpagesection(MERGING EXCLUDE FILES)
+ Let's say that we want to match two source files, one with an absolute
+ path of "/home/me/foo/bar", and one with a path of "/home/you/bar/baz".
+@@ -1178,23 +1187,27 @@ because rsync did not descend through th
+ hierarchy.
+
+ Note also that the --include and --exclude options take one pattern
+-each. To add multiple patterns use the --include-from and
+---exclude-from options or multiple --include and --exclude options.
++each. To add multiple patterns use the --include-from and --exclude-from
++options or multiple --include and --exclude options.
+
+-The patterns can take several forms. The rules are:
++The include/exclude patterns can take several forms. The rules are:
+
+ itemize(
+
+- it() if the pattern starts with a / then it is matched against the
+- start of the filename, otherwise it is matched against the end of
+- the filename.
+- This is the equivalent of a leading ^ in regular expressions.
+- Thus "/foo" would match a file called "foo" at the transfer-root
+- (see above for how this is different from the filesystem-root).
+- On the other hand, "foo" would match any file called "foo"
++ it() if the pattern starts with a / then it is anchored to a
++ particular spot in the hierarchy of files, otherwise it is matched
++ against the end of the pathname. This is similar to a leading ^ in
++ regular expressions.
++ Thus "/foo" would match a file called "foo" at either the "root of the
++ transfer" (for a global rule) or in the merge-file's directory (for a
++ per-directory rule).
++ An unqualified "foo" would match any file or directory named "foo"
+ anywhere in the tree because the algorithm is applied recursively from
++ the
+ top down; it behaves as if each path component gets a turn at being the
+- end of the file name.
++ end of the file name. Even the unanchored "sub/foo" would match at
++ any point in the hierarchy where a "foo" was found within a directory
++ named "sub".
+
+ it() if the pattern ends with a / then it will only match a
+ directory, not a file, link, or device.
+@@ -1207,22 +1220,44 @@ itemize(
+ single asterisk pattern "*" will stop at slashes.
+
+ it() if the pattern contains a / (not counting a trailing /) or a "**"
+- then it is matched against the full filename, including any leading
+- directory. If the pattern doesn't contain a / or a "**", then it is
++ then it is matched against the full pathname, including any leading
++ directories. If the pattern doesn't contain a / or a "**", then it is
+ matched only against the final component of the filename. Again,
+ remember that the algorithm is applied recursively so "full filename" can
+ actually be any portion of a path below the starting directory.
+
+- it() if the pattern starts with "+ " (a plus followed by a space)
+- then it is always considered an include pattern, even if specified as
+- part of an exclude option. The prefix is discarded before matching.
+-
+- it() if the pattern starts with "- " (a minus followed by a space)
+- then it is always considered an exclude pattern, even if specified as
+- part of an include option. The prefix is discarded before matching.
++ it() if the pattern starts with "+" (a plus), the actual pattern begins
++ after the first space, and is always considered to be an include pattern,
++ even if specified as part of an exclude file/option. Option letters may
++ follow the "+" prior to the separating space (see below).
++
++ it() if the pattern starts with "-" (a minus), the actual pattern begins
++ after the first space, and is always considered to be an exclude pattern,
++ even if specified as part of an include file/option. Option letters may
++ follow the "-" prior to the separating space (see below).
+
+- it() if the pattern is a single exclamation mark ! then the current
++ it() if the pattern is a "!" (single exclamation mark) then the current
+ include/exclude list is reset, removing all previously defined patterns.
++ The "current" list is either the global list of rules (which are
++ specified via options) or a set of per-directory rules (which are
++ inherited in their own sub-list, so a subdirectory can use this to
++ clear out the parent's rules).
++
++)
+
-+You can merge whole files into an exclude file using a rule that starts
-+with a ". " (a dot followed by a space) and has a filename in place of the
-+pattern. There are two types of merge rules, single-instance and
-+per-directory:
++For a line that starts with a "+" (plus) or a "-" (minus), the following
++option letters may be suffixed:
+
+itemize(
-+ it() If the filename has no slashes in it, it is a per-directory merge;
-+ rsync scans every directory that it traverses for the named file, merging
-+ its contents (when it exists) file at the start of this per-directory
-+ sub-list (subdirectories inherit the contents of their parent directories
-+ by default, and each subdirectory's rules have precedence over the parent
-+ directory's rules).
-+
-+ it() If a filename has a slash in it, it is a single-instance merge; the
-+ named file's contents will be merged into the current exclude file,
-+ replacing the merge rule. Thus, you should use the name ./foo instead of
-+ foo if you don't want to scan for "foo" in all the subdirectories of the
-+ current directory.
++
++ it() An "m" means that the string following the space is to be taken to
++ be a merge-file that is read in to supplement the current rules. See the
++ section on MERGED EXCLUDE FILES for more information.
++
++ it() A "p" means that the string following the space is to be taken to be
++ a per-directory merge-file that is read in to supplement the current
++ rules. See the section on MERGED EXCLUDE FILES for more information.
++
+ )
+
+ The +/- rules are most useful in a list that was read from a file, allowing
+@@ -1269,8 +1304,157 @@ itemize(
+ it() --include "*/" --include "*.c" --exclude "*" would include all
+ directories and C source files
+ it() --include "foo/" --include "foo/bar.c" --exclude "*" would include
+- only foo/bar.c (the foo/ directory must be explicitly included or
+- it would be excluded by the "*")
++ only the foo directory and foo/bar.c (the foo directory must be
++ explicitly included or it would be excluded by the "*")
+)
+
-+Note also that you can eliminate all the inherited rules for the current
-+per-directory ruleset by putting the list-clearing token (!) in the file.
-+This only clears the rules for the current per-directory sub-list (up
-+through the ! token) and only for the current directory and its
-+subdirectories.
++manpagesection(MERGED EXCLUDE FILES)
+
-+Here's an example exclude file (which you'd specify via the normal
-+--exclude-from option):
++You can merge whole files into an exclude file by specifying either the
++"m" or "p" option following the initial "+" or "-", and putting a filename
++in place of the pattern. There are two kinds of merged exclude files --
++single-instance ("m") and per-directory ("p"). For example:
+
+verb(
-+ . /home/user/.global_excludes
-+ - *.gz
-+ . .excl
++ -m /etc/rsync/default.excludes
++ +p .per-dir-includes
++)
++
++For a per-directory merge file, rsync will scan
++every directory that it traverses for the named file, merging its contents
++when the file exists. These exclude files must exist on the sending side
++because it is the sending side that is being scanned for available files
++to send. The files may also need to be transferred to the receiving side
++if you want them to affect what files don't get deleted (see PER-DIRECTORY
++EXCLUDES AND DELETE below).
++
++Per-directory rules are inherited in all subdirectories of the directory
++where the merge-file was found. Each subdirectory's rules are prefixed
++to the inherited rules from the parent directories, which gives the
++newest rules a higher priority than the inherited rules. The entire set
++of per-dir rules is grouped together in the spot where the merge-file was
++specified, so it is possible to override per-dir rules via a rule that
++got specified earlier in the list of global rules.
++
++If you don't want a per-dir rule to be inherited, anchor it with a leading
++slash. Anchored rules in a per-directory merge-file are relative to the
++merge-file's directory, so a rule "/foo" would only exclude the file "foo"
++in the directory where the per-dir exclude file was found.
++
++Here's an example exclude file which you'd specify via the normal
++--exclude-from=FILE option:
++
++verb(
++ -m /home/user/.global_excludes
++ *.gz
++ +p .incl
+ + *.[ch]
-+ - *.o
++ *.o
+)
+
+This will merge the contents of the /home/user/.global_excludes file at the
-+start of the list and also turns the ".excl" filename into a per-directory
-+exclude file whose local contents will be merged into the list in place of
-+the .excl line.
++start of the list and also turns the ".incl" filename into a per-directory
++include file. All rules read in prior to the start of the directory scan
++follow the global anchoring rules (i.e. a leading slash matches at the root
++of the transfer).
++
++If a per-directory merge-file is specified with a path that is a parent
++directory of the first transfer directory, rsync will scan all the parent
++dirs from that starting point to the transfer directory for the indicated
++per-directory file. For instance, the -E option is an abbreviation for
++this command:
++
++verb(
++ --exclude='-p /.rsync-excludes'
++)
++
++That exclude tells rsync to scan for the file .rsync-excludes in all
++directories from the root down through the source of the transfer. (For
++an rsync daemon, the "root dir" is always the module's "path" setting.)
++
++Some examples of this pre-scanning for per-directory files:
++
++verb(
++ rsync -avE /src/path/ /dest/dir
++ rsync -av --exclude='-p ../../.rsync-excludes' /src/path/ /dest/dir
++ rsync -av --exclude='-p .rsync-excludes' /src/path/ /dest/dir
++)
++
++The first two commands above will look for ".rsync-excludes" in "/" and
++"/src" before the normal scan begins looking for the file in "/src/path"
++and its subdirectories. The last command avoids the parent-dir scan
++and only looks for the ".rsync-excludes" files in each directory that is
++a part of the transfer.
++
++Finally, note that the parsing of any merge-file named ".cvsignore" is
++always done in a CVS-compatible manner, even if -C wasn't specified. This
++means that its rules are always excludes (even if an include option
++specified the file), patterns are split on whitespace, the rules are never
++inherited, and no special characters are honored except for "!" (e.g. no
++comments, and no +/- prefixes).
+
+Additionally, you can affect where the --cvs-exclude (-C) option's
-+inclusion of a per-directory .cvsignore file gets placed into your rules by
-+adding an explicit merge rule for ".cvsignore". For instance, specifying
-+this:
++inclusion of the per-directory .cvsignore file gets placed into your rules
++by adding your own explicit per-directory merge rule for ".cvsignore".
++Without this, rsync would add this rule at the end of all your other
++rules (giving it a lower priority than your command-line rules). For
++example:
++
++verb(
++ rsync -avC --exclude='-p .cvsignore' --exclude-from=foo a/ b
++)
++
++The above will merge all the per-directory .cvsignore rules at the start of
++your list rather than at the end. This allows their dir-specific rules to
++supersede your rules instead of being subservient to them. (The global
++rules taken from the $HOME/.cvsignore file and from $CVSIGNORE are not
++repositioned by this.)
++
++manpagesection(PER-DIRECTORY EXCLUDES AND DELETE)
++
++Without a delete option, per-directory excludes are only relevant on the
++sending side, so you can feel free to exclude the merge files themselves
++without affecting the transfer:
+
+verb(
-+ rsync -avC --exclude='. .cvsignore' --exclude-from=foo a/ b
++ rsync -av --exclude='-p .excl' --exclude=.excl host:src/dir /dest
+)
+
-+will merge all the per-directory .cvsignore rules at the start of your list
-+rather than at the end. This allows their dir-specific rules to supersede
-+your rules instead of being subservient to them. (The global rules taken
-+from the $HOME/.cvsignore file and from $CVSIGNORE are not affected by
-+this.)
++However, if you want to do a delete on the receiving side AND you want some
++files to be excluded from being deleted, you'll need to be sure that the
++receiving side knows what files to exclude. The easiest way is to include
++the per-directory merge files in the transfer and use --delete-after
++because this ensures that the receiving side gets all the same exclude
++rules as the sending side before it tries to delete anything:
++
++verb(
++ rsync -avE --delete-after host:src/dir /dest
++)
+
-+Note also that the parsing of any merge-file named ".cvsignore" is always
-+done in a CVS-compatible manner (even if -C wasn't specified) -- i.e. the
-+rules are always exclude rules (even when specified by an include option),
-+they are split on whitespace, no special prefixes or list-clearing tokens
-+are honored, and (for per-directory files) subdirectories don't inherit the
-+parent directory's rules.
++However, if the merge files are not a part of the transfer, you'll need
++to either use a global exclude rule (i.e. specified on the command line),
++or you'll need to maintain your own per-directory merge files on the
++receiving side. An example of the first is this (assume that the remote
++.ctrl files exclude themselves):
+
++verb(
++ rsync -av --exclude='-p .ctrl' --exclude-from=/my/extra.rules
++ --delete host:src/dir /dest
++)
++
++In the above example the extra.rules file can affect both sides of the
++transfer, but the rules are subservient to the rules merged from the .ctrl
++files because they were specified after the per-directory merge rule.
++
++In one final example, the remote side is excluding the .rsync-excludes
++files from the transfer, but we want to use our own .rsync-excludes files
++to control what gets deleted on the receiving side. To do this we must
++specifically exclude the per-directory merge files (so that they don't get
++deleted) and then put rules into the local files to control what else
++should not get deleted. Like this:
++
++verb(
++ rsync -avE --exclude=.rsync-excludes --delete host:src/dir /dest
+ )
+
manpagesection(BATCH MODE)
+--- orig/testsuite/exclude.test 2004-05-29 21:25:45
++++ testsuite/exclude.test 2005-01-14 00:14:33
+@@ -23,19 +23,47 @@ export HOME CVSIGNORE
+ makepath "$fromdir/foo/down/to/you"
+ makepath "$fromdir/bar/down/to/foo/too"
+ makepath "$fromdir/mid/for/foo/and/that/is/who"
++cat >"$fromdir/.excl" <<EOF
++.excl
++*.bak
++*.old
++*.junk
++EOF
+ echo kept >"$fromdir/foo/file1"
+ echo removed >"$fromdir/foo/file2"
+ echo cvsout >"$fromdir/foo/file2.old"
++cat >"$fromdir/foo/.excl" <<EOF
+++ .excl
++- file1
++EOF
++cat >"$fromdir/bar/.excl" <<EOF
++home-cvs-exclude
++-p .excl2
+++ to
++EOF
+ echo cvsout >"$fromdir/bar/down/to/home-cvs-exclude"
++cat >"$fromdir/bar/down/to/.excl2" <<EOF
++.excl2
++EOF
+ echo keeper >"$fromdir/bar/down/to/foo/file1"
+ echo cvsout >"$fromdir/bar/down/to/foo/file1.bak"
+ echo gone >"$fromdir/bar/down/to/foo/file3"
+ echo lost >"$fromdir/bar/down/to/foo/file4"
+ echo cvsout >"$fromdir/bar/down/to/foo/file4.junk"
+ echo smashed >"$fromdir/bar/down/to/foo/to"
++cat >"$fromdir/bar/down/to/foo/.excl2" <<EOF
+++ *.junk
++EOF
++# This one should be ineffectual
++cat >"$fromdir/mid/.excl2" <<EOF
++extra
++EOF
+ echo cvsout >"$fromdir/mid/one-in-one-out"
+ echo one-in-one-out >"$fromdir/mid/.cvsignore"
+ echo cvsin >"$fromdir/mid/one-for-all"
++cat >"$fromdir/mid/.excl" <<EOF
++-p .cvsignore
++EOF
+ echo cvsin >"$fromdir/mid/for/one-in-one-out"
+ echo expunged >"$fromdir/mid/for/foo/extra"
+ echo retained >"$fromdir/mid/for/foo/keep"
+@@ -100,5 +128,24 @@ $RSYNC -av --existing --include='*/' --e
+ checkit "$RSYNC -avvC --exclude-from=\"$excl\" \
+ --delete-excluded \"$fromdir/\" \"$todir/\"" "$chkdir" "$todir"
- bf(Note:) Batch mode should be considered experimental in this version
++# Modify the chk dir for our merge-exclude test and then tweak the dir times.
++
++rm "$chkdir"/.excl
++rm "$chkdir"/foo/file1
++rm "$chkdir"/bar/.excl
++rm "$chkdir"/bar/down/to/.excl2
++rm "$chkdir"/bar/down/to/foo/.excl2
++rm "$chkdir"/mid/.excl
++cp -p "$fromdir"/bar/down/to/foo/*.junk "$chkdir"/bar/down/to/foo
++cp -p "$fromdir"/bar/down/to/foo/to "$chkdir"/bar/down/to/foo
++
++$RSYNC -av --existing --include='*/' --exclude='*' "$fromdir/" "$chkdir/"
++
++# Now, test if rsync excludes the same files, this time with a merge-exclude
++# file.
++
++checkit "$RSYNC -avv --exclude='-p .excl' --exclude-from=\"$excl\" \
++ --delete-excluded \"$fromdir/\" \"$todir/\"" "$chkdir" "$todir"
++
+ # The script would have aborted on error, so getting here means we've won.
+ exit 0
Matt McCutchen's Web Site / rsync / rsync-patches.git / blobdiff