Improve the testing of tar -X and try to correctly handle some odd cases.

Here are some of the cases currently handled
(assuming test.tar contains a single entry "file1"):

 $ tar xf test.tar file1

Extracts file1 with no error.

 $ tar xf test.tar file1 file2

Extracts file1, error because file2 was requested but not found.

 $ tar xf test.tar file1 'file2*'

Extracts file1, error because 'file2*' pattern matched no entries.

 $ tar xf test.tar file1 file1

Extracts file1 with no error

 $ tar xf test.tar file1 'file*'

Extracts file1 with no error

 $ tar xf test.tar --exclude=file1

Does not extract file1, no error.

 $ tar xf test.tar --exclude=file1 file1

Does not extract file1, no error.

 $ tar xf test.tar --exclude=file2 file1

Extracts file1, no error.

SVN-Revision: 2229

1 files changed, 26 insertions, 29 deletions

diff --git a/libarchive_fe/matching.c b/libarchive_fe/matching.c
index f774ac77..b2aba022 100644
--- a/libarchive_fe/matching.c
+++ b/libarchive_fe/matching.c
@@ -156,40 +156,41 @@ lafe_excluded(struct lafe_matching *matching, const char *pathname)
 	if (matching == NULL)
 		return (0);
 
+	/* Mark off any unmatched inclusions. */
+	/* In particular, if a filename does appear in the archive and
+	 * is explicitly included and excluded, then we don't report
+	 * it as missing even though we don't extract it.
+	 */
+	matched = NULL;
+	for (match = matching->inclusions; match != NULL; match = match->next){
+		if (match->matches == 0
+		    && match_inclusion(match, pathname)) {
+			matching->inclusions_unmatched_count--;
+			match->matches++;
+			matched = match;
+		}
+	}
+
 	/* Exclusions take priority */
 	for (match = matching->exclusions; match != NULL; match = match->next){
 		if (match_exclusion(match, pathname))
 			return (1);
 	}
 
-	/* Then check for inclusions */
-	matched = NULL;
+	/* It's not excluded and we found an inclusion above, so it's included. */
+	if (matched != NULL)
+		return (0);
+
+
+	/* We didn't find an unmatched inclusion, check the remaining ones. */
 	for (match = matching->inclusions; match != NULL; match = match->next){
-		if (match_inclusion(match, pathname)) {
-			/*
-			 * If this pattern has never been matched,
-			 * then we're done.
-			 */
-			if (match->matches == 0) {
-				match->matches++;
-				matching->inclusions_unmatched_count--;
-				return (0);
-			}
-			/*
-			 * Otherwise, remember the match but keep checking
-			 * in case we can tick off an unmatched pattern.
-			 */
-			matched = match;
+		/* We looked at previously-unmatched inclusions already. */
+		if (match->matches > 0
+		    && match_inclusion(match, pathname)) {
+			match->matches++;
+			return (0);
 		}
 	}
-	/*
-	 * We didn't find a pattern that had never been matched, but
-	 * we did find a match, so count it and exit.
-	 */
-	if (matched != NULL) {
-		matched->matches++;
-		return (0);
-	}
 
 	/* If there were inclusions, default is to exclude. */
 	if (matching->inclusions != NULL)
@@ -219,11 +220,7 @@ match_exclusion(struct match *match, const char *pathname)
 static int
 match_inclusion(struct match *match, const char *pathname)
 {
-#if 0
-	return (lafe_pathmatch(match->pattern, pathname, 0));
-#else
 	return (lafe_pathmatch(match->pattern, pathname, PATHMATCH_NO_ANCHOR_END));
-#endif	
 }
 
 void