/*-

 * Copyright (c) 2003-2007 Tim Kientzle

 * Copyright (c) 2012 Michihiro NAKAJIMA

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "archive_platform.h"

__FBSDID("$FreeBSD$");

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#include "archive.h"

#include "archive_private.h"

#include "archive_entry.h"

#include "archive_getdate.h"

#include "archive_pathmatch.h"

#include "archive_rb.h"

#include "archive_string.h"

struct match {

	struct match		*next;

	int			 matches;

	struct archive_mstring	 pattern;

};

struct match_list {

	struct match		*first;

	struct match		**last;

	int			 count;

	int			 unmatched_count;

	struct match		*unmatched_next;

	int			 unmatched_eof;

};

struct match_file {

	struct archive_rb_node	 node;

	struct match_file	*next;

	struct archive_mstring	 pathname;

	int			 flag;

	time_t			 mtime_sec;

	long			 mtime_nsec;

	time_t			 ctime_sec;

	long			 ctime_nsec;

};

struct entry_list {

	struct match_file	*first;

	struct match_file	**last;

	int			 count;

};

struct id_array {

	size_t			 size;/* Allocated size */

	size_t			 count;

	int64_t			*ids;

};

#define PATTERN_IS_SET		1

#define TIME_IS_SET		2

#define ID_IS_SET		4

struct archive_match {

	struct archive		 archive;

	/* exclusion/inclusion set flag. */

	int			 setflag;

	/*

	 * Matching filename patterns.

	 */

	struct match_list	 exclusions;

	struct match_list	 inclusions;

	/*

	 * Matching time stamps.

	 */

	time_t			 now;

	int			 newer_mtime_filter;

	time_t			 newer_mtime_sec;

	long			 newer_mtime_nsec;

	int			 newer_ctime_filter;

	time_t			 newer_ctime_sec;

	long			 newer_ctime_nsec;

	int			 older_mtime_filter;

	time_t			 older_mtime_sec;

	long			 older_mtime_nsec;

	int			 older_ctime_filter;

	time_t			 older_ctime_sec;

	long			 older_ctime_nsec;

	/*

	 * Matching time stamps with its filename.

	 */

	struct archive_rb_tree	 exclusion_tree;

	struct entry_list 	 exclusion_entry_list;

	/*

	 * Matching file owners.

	 */

	struct id_array 	 inclusion_uids;

	struct id_array 	 inclusion_gids;

	struct match_list	 inclusion_unames;

	struct match_list	 inclusion_gnames;

};

static int	add_pattern_from_file(struct archive_match *,

		    struct match_list *, int, const void *, int);

static int	add_entry(struct archive_match *, int,

		    struct archive_entry *);

static int	add_owner_id(struct archive_match *, struct id_array *,

		    int64_t);

static int	add_owner_name(struct archive_match *, struct match_list *,

		    int, const void *);

static int	add_pattern_mbs(struct archive_match *, struct match_list *,

		    const char *);

static int	add_pattern_wcs(struct archive_match *, struct match_list *,

		    const wchar_t *);

static int	cmp_key_mbs(const struct archive_rb_node *, const void *);

static int	cmp_key_wcs(const struct archive_rb_node *, const void *);

static int	cmp_node_mbs(const struct archive_rb_node *,

		    const struct archive_rb_node *);

static int	cmp_node_wcs(const struct archive_rb_node *,

		    const struct archive_rb_node *);

static void	entry_list_add(struct entry_list *, struct match_file *);

static void	entry_list_free(struct entry_list *);

static void	entry_list_init(struct entry_list *);

static int	error_nomem(struct archive_match *);

static void	match_list_add(struct match_list *, struct match *);

static void	match_list_free(struct match_list *);

static void	match_list_init(struct match_list *);

static int	match_list_unmatched_inclusions_next(struct archive_match *,

		    struct match_list *, int, const void **);

static int	match_owner_id(struct id_array *, int64_t);

#if !defined(_WIN32) || defined(__CYGWIN__)

static int	match_owner_name_mbs(struct archive_match *,

		    struct match_list *, const char *);

#else

static int	match_owner_name_wcs(struct archive_match *,

		    struct match_list *, const wchar_t *);

#endif

static int	match_path_exclusion(struct archive_match *,

		    struct match *, int, const void *);

static int	match_path_inclusion(struct archive_match *,

		    struct match *, int, const void *);

static int	owner_excluded(struct archive_match *,

		    struct archive_entry *);

static int	path_excluded(struct archive_match *, int, const void *);

static int	set_timefilter(struct archive_match *, int, time_t, long,

		    time_t, long);

static int	set_timefilter_pathname_mbs(struct archive_match *,

		    int, const char *);

static int	set_timefilter_pathname_wcs(struct archive_match *,

		    int, const wchar_t *);

static int	set_timefilter_date(struct archive_match *, int, const char *);

static int	set_timefilter_date_w(struct archive_match *, int,

		    const wchar_t *);

static int	time_excluded(struct archive_match *,

		    struct archive_entry *);

static int	validate_time_flag(struct archive *, int, const char *);

#define get_date __archive_get_date

static const struct archive_rb_tree_ops rb_ops_mbs = {

	cmp_node_mbs, cmp_key_mbs

};

static const struct archive_rb_tree_ops rb_ops_wcs = {

	cmp_node_wcs, cmp_key_wcs

};

/*

 * The matching logic here needs to be re-thought.  I started out to

 * try to mimic gtar's matching logic, but it's not entirely

 * consistent.  In particular 'tar -t' and 'tar -x' interpret patterns

 * on the command line as anchored, but --exclude doesn't.

 */

static int

error_nomem(struct archive_match *a)

{

	archive_set_error(&(a->archive), ENOMEM, "No memory");

	a->archive.state = ARCHIVE_STATE_FATAL;

	return (ARCHIVE_FATAL);

}

/*

 * Create an ARCHIVE_MATCH object.

 */

struct archive *

archive_match_new(void)

{

	struct archive_match *a;

	a = (struct archive_match *)calloc(1, sizeof(*a));

	if (a == NULL)

		return (NULL);

	a->archive.magic = ARCHIVE_MATCH_MAGIC;

	a->archive.state = ARCHIVE_STATE_NEW;

	match_list_init(&(a->inclusions));

	match_list_init(&(a->exclusions));

	__archive_rb_tree_init(&(a->exclusion_tree), &rb_ops_mbs);

	entry_list_init(&(a->exclusion_entry_list));

	match_list_init(&(a->inclusion_unames));

	match_list_init(&(a->inclusion_gnames));

	time(&a->now);

	return (&(a->archive));

}

/*

 * Free an ARCHIVE_MATCH object.

 */

int

archive_match_free(struct archive *_a)

{

	struct archive_match *a;

	if (_a == NULL)

		return (ARCHIVE_OK);

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_match_free");

	a = (struct archive_match *)_a;

	match_list_free(&(a->inclusions));

	match_list_free(&(a->exclusions));

	entry_list_free(&(a->exclusion_entry_list));

	free(a->inclusion_uids.ids);

	free(a->inclusion_gids.ids);

	match_list_free(&(a->inclusion_unames));

	match_list_free(&(a->inclusion_gnames));

	free(a);

	return (ARCHIVE_OK);

}

/*

 * Convenience function to perform all exclusion tests.

 *

 * Returns 1 if archive entry is excluded.

 * Returns 0 if archive entry is not excluded.

 * Returns <0 if something error happened.

 */

int

archive_match_excluded(struct archive *_a, struct archive_entry *entry)

{

	struct archive_match *a;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_excluded_ae");

	a = (struct archive_match *)_a;

	if (entry == NULL) {

		archive_set_error(&(a->archive), EINVAL, "entry is NULL");

		return (ARCHIVE_FAILED);

	}

	r = 0;

	if (a->setflag & PATTERN_IS_SET) {

#if defined(_WIN32) && !defined(__CYGWIN__)

		r = path_excluded(a, 0, archive_entry_pathname_w(entry));

#else

		r = path_excluded(a, 1, archive_entry_pathname(entry));

#endif

		if (r != 0)

			return (r);

	}

	if (a->setflag & TIME_IS_SET) {

		r = time_excluded(a, entry);

		if (r != 0)

			return (r);

	}

	if (a->setflag & ID_IS_SET)

		r = owner_excluded(a, entry);

	return (r);

}

/*

 * Utility functions to manage exclusion/inclusion patterns

 */

int

archive_match_exclude_pattern(struct archive *_a, const char *pattern)

{

	struct archive_match *a;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_exclude_pattern");

	a = (struct archive_match *)_a;

	if (pattern == NULL || *pattern == '\0') {

		archive_set_error(&(a->archive), EINVAL, "pattern is empty");

		return (ARCHIVE_FAILED);

	}

	if ((r = add_pattern_mbs(a, &(a->exclusions), pattern)) != ARCHIVE_OK)

		return (r);

	return (ARCHIVE_OK);

}

int

archive_match_exclude_pattern_w(struct archive *_a, const wchar_t *pattern)

{

	struct archive_match *a;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_exclude_pattern_w");

	a = (struct archive_match *)_a;

	if (pattern == NULL || *pattern == L'\0') {

		archive_set_error(&(a->archive), EINVAL, "pattern is empty");

		return (ARCHIVE_FAILED);

	}

	if ((r = add_pattern_wcs(a, &(a->exclusions), pattern)) != ARCHIVE_OK)

		return (r);

	return (ARCHIVE_OK);

}

int

archive_match_exclude_pattern_from_file(struct archive *_a,

    const char *pathname, int nullSeparator)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_exclude_pattern_from_file");

	a = (struct archive_match *)_a;

	return add_pattern_from_file(a, &(a->exclusions), 1, pathname,

		nullSeparator);

}

int

archive_match_exclude_pattern_from_file_w(struct archive *_a,

    const wchar_t *pathname, int nullSeparator)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_exclude_pattern_from_file_w");

	a = (struct archive_match *)_a;

	return add_pattern_from_file(a, &(a->exclusions), 0, pathname,

		nullSeparator);

}

int

archive_match_include_pattern(struct archive *_a, const char *pattern)

{

	struct archive_match *a;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_include_pattern");

	a = (struct archive_match *)_a;

	if (pattern == NULL || *pattern == '\0') {

		archive_set_error(&(a->archive), EINVAL, "pattern is empty");

		return (ARCHIVE_FAILED);

	}

	if ((r = add_pattern_mbs(a, &(a->inclusions), pattern)) != ARCHIVE_OK)

		return (r);

	return (ARCHIVE_OK);

}

int

archive_match_include_pattern_w(struct archive *_a, const wchar_t *pattern)

{

	struct archive_match *a;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_include_pattern_w");

	a = (struct archive_match *)_a;

	if (pattern == NULL || *pattern == L'\0') {

		archive_set_error(&(a->archive), EINVAL, "pattern is empty");

		return (ARCHIVE_FAILED);

	}

	if ((r = add_pattern_wcs(a, &(a->inclusions), pattern)) != ARCHIVE_OK)

		return (r);

	return (ARCHIVE_OK);

}

int

archive_match_include_pattern_from_file(struct archive *_a,

    const char *pathname, int nullSeparator)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_include_pattern_from_file");

	a = (struct archive_match *)_a;

	return add_pattern_from_file(a, &(a->inclusions), 1, pathname,

		nullSeparator);

}

int

archive_match_include_pattern_from_file_w(struct archive *_a,

    const wchar_t *pathname, int nullSeparator)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_include_pattern_from_file_w");

	a = (struct archive_match *)_a;

	return add_pattern_from_file(a, &(a->inclusions), 0, pathname,

		nullSeparator);

}

/*

 * Test functions for pathname patterns.

 *

 * Returns 1 if archive entry is excluded.

 * Returns 0 if archive entry is not excluded.

 * Returns <0 if something error happened.

 */

int

archive_match_path_excluded(struct archive *_a,

    struct archive_entry *entry)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_path_excluded");

	a = (struct archive_match *)_a;

	if (entry == NULL) {

		archive_set_error(&(a->archive), EINVAL, "entry is NULL");

		return (ARCHIVE_FAILED);

	}

	/* If we don't have exclusion/inclusion pattern set at all,

	 * the entry is always not excluded. */

	if ((a->setflag & PATTERN_IS_SET) == 0)

		return (0);

#if defined(_WIN32) && !defined(__CYGWIN__)

	return (path_excluded(a, 0, archive_entry_pathname_w(entry)));

#else

	return (path_excluded(a, 1, archive_entry_pathname(entry)));

#endif

}

/*

 * Utility functions to get statistic information for inclusion patterns.

 */

int

archive_match_path_unmatched_inclusions(struct archive *_a)

{

	struct archive_match *a;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_unmatched_inclusions");

	a = (struct archive_match *)_a;

	return (a->inclusions.unmatched_count);

}

int

archive_match_path_unmatched_inclusions_next(struct archive *_a,

    const char **_p)

{

	struct archive_match *a;

	const void *v;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_unmatched_inclusions_next");

	a = (struct archive_match *)_a;

	r = match_list_unmatched_inclusions_next(a, &(a->inclusions), 1, &v);

	*_p = (const char *)v;

	return (r);

}

int

archive_match_path_unmatched_inclusions_next_w(struct archive *_a,

    const wchar_t **_p)

{

	struct archive_match *a;

	const void *v;

	int r;

	archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_match_unmatched_inclusions_next_w");

	a = (struct archive_match *)_a;

	r = match_list_unmatched_inclusions_next(a, &(a->inclusions), 0, &v);

	*_p = (const wchar_t *)v;

	return (r);

}

/*

 * Add inclusion/exclusion patterns.

 */

static int

add_pattern_mbs(struct archive_match *a, struct match_list *list,

    const char *pattern)

{

	struct match *match;

	size_t len;

	match = calloc(1, sizeof(*match));

	if (match == NULL)

		return (error_nomem(a));

	/* Both "foo/" and "foo" should match "foo/bar". */

	len = strlen(pattern);

	if (len && pattern[len - 1] == '/')

		--len;

	archive_mstring_copy_mbs_len(&(match->pattern), pattern, len);

	match_list_add(list, match);

	a->setflag |= PATTERN_IS_SET;

	return (ARCHIVE_OK);

}

static int

add_pattern_wcs(struct archive_match *a, struct match_list *list,

    const wchar_t *pattern)

{

	struct match *match;

	size_t len;

	match = calloc(1, sizeof(*match));

	if (match == NULL)

		return (error_nomem(a));

	/* Both "foo/" and "foo" should match "foo/bar". */

	len = wcslen(pattern);

	if (len && pattern[len - 1] == L'/')

		--len;

	archive_mstring_copy_wcs_len(&(match->pattern), pattern, len);

	match_list_add(list, match);

	a->setflag |= PATTERN_IS_SET;

	return (ARCHIVE_OK);

}

static int

add_pattern_from_file(struct archive_match *a, struct match_list *mlist,

    int mbs, const void *pathname, int nullSeparator)

{

	struct archive *ar;

	struct archive_entry *ae;

	struct archive_string as;

	const void *buff;

	size_t size;

	int64_t offset;

	int r;

	ar = archive_read_new(); 

	if (ar == NULL) {

		archive_set_error(&(a->archive), ENOMEM, "No memory");

		return (ARCHIVE_FATAL);

	}

	r = archive_read_support_format_raw(ar);

	r = archive_read_support_format_empty(ar);

	if (r != ARCHIVE_OK) {

		archive_copy_error(&(a->archive), ar);

		archive_read_free(ar);

		return (r);

	}

	if (mbs)

		r = archive_read_open_filename(ar, pathname, 512*20);

	else

		r = archive_read_open_filename_w(ar, pathname, 512*20);

	if (r != ARCHIVE_OK) {

		archive_copy_error(&(a->archive), ar);

		archive_read_free(ar);

		return (r);

	}

	r = archive_read_next_header(ar, &ae);

	if (r != ARCHIVE_OK) {

		archive_read_free(ar);

		if (r == ARCHIVE_EOF) {

			return (ARCHIVE_OK);

		} else {

			archive_copy_error(&(a->archive), ar);

			return (r);

		}

	}

	archive_string_init(&as);

	while ((r = archive_read_data_block(ar, &buff, &size, &offset))

	    == ARCHIVE_OK) {

		const char *b = (const char *)buff;

		while (size) {

			const char *s = (const char *)b;

			size_t length = 0;

			int found_separator = 0;

			while (length < size) {

				if (nullSeparator) {

					if (*b == '\0') {

						found_separator = 1;

						break;

					}

				} else {

			            	if (*b == 0x0d || *b == 0x0a) {

						found_separator = 1;

						break;

					}

				}

				b++;

				length++;

			}

			if (!found_separator) {

				archive_strncat(&as, s, length);

				/* Read next data block. */

				break;

			}

			b++;

			size -= length + 1;

			archive_strncat(&as, s, length);

			/* If the line is not empty, add the pattern. */

			if (archive_strlen(&as) > 0) {

				/* Add pattern. */

				r = add_pattern_mbs(a, mlist, as.s);

				if (r != ARCHIVE_OK) {

					archive_read_free(ar);

					archive_string_free(&as);

					return (r);

				}

				archive_string_empty(&as);

			}

		}

	}

	/* If an error occurred, report it immediately. */

	if (r < ARCHIVE_OK) {

		archive_copy_error(&(a->archive), ar);

		archive_read_free(ar);

		archive_string_free(&as);

		return (r);

	}

	/* If the line is not empty, add the pattern. */

	if (r == ARCHIVE_EOF && archive_strlen(&as) > 0) {

		/* Add pattern. */

		r = add_pattern_mbs(a, mlist, as.s);

		if (r != ARCHIVE_OK) {

			archive_read_free(ar);

			archive_string_free(&as);

			return (r);

		}

	}

	archive_read_free(ar);

	archive_string_free(&as);

	return (ARCHIVE_OK);

}

/*

 * Test if pathname is excluded by inclusion/exclusion patterns.

 */

static int

path_excluded(struct archive_match *a, int mbs, const void *pathname)

{

	struct match *match;

	struct match *matched;

	int r;

	if (a == 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 = a->inclusions.first; match != NULL;

	    match = match->next){

		if (match->matches == 0 &&

		    (r = match_path_inclusion(a, match, mbs, pathname)) != 0) {

			if (r < 0)

				return (r);

			a->inclusions.unmatched_count--;

			match->matches++;

			matched = match;

		}

	}

	/* Exclusions take priority */

	for (match = a->exclusions.first; match != NULL;

	    match = match->next){

		r = match_path_exclusion(a, match, mbs, pathname);

		if (r)

			return (r);

	}

	/* 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 = a->inclusions.first; match != NULL;

	    match = match->next){

		/* We looked at previously-unmatched inclusions already. */

		if (match->matches > 0 &&

		    (r = match_path_inclusion(a, match, mbs, pathname)) != 0) {

			if (r < 0)

				return (r);

			match->matches++;

			return (0);

		}

	}

	/* If there were inclusions, default is to exclude. */

	if (a->inclusions.first != NULL)

	    return (1);

	/* No explicit inclusions, default is to match. */

	return (0);

}

/*

 * This is a little odd, but it matches the default behavior of

 * gtar.  In particular, 'a*b' will match 'foo/a1111/222b/bar'

 *

 */

static int

match_path_exclusion(struct archive_match *a, struct match *m,

    int mbs, const void *pn)

{

	int flag = PATHMATCH_NO_ANCHOR_START | PATHMATCH_NO_ANCHOR_END;

	int r;

	if (mbs) {

		const char *p;

		r = archive_mstring_get_mbs(&(a->archive), &(m->pattern), &p);

		if (r == 0)

			return (archive_pathmatch(p, (const char *)pn, flag));

	} else {

		const wchar_t *p;

		r = archive_mstring_get_wcs(&(a->archive), &(m->pattern), &p);

		if (r == 0)

			return (archive_pathmatch_w(p, (const wchar_t *)pn,

				flag));

	}

	if (errno == ENOMEM)

		return (error_nomem(a));

	return (0);

}

/*

 * Again, mimic gtar:  inclusions are always anchored (have to match

 * the beginning of the path) even though exclusions are not anchored.

 */

static int

match_path_inclusion(struct archive_match *a, struct match *m,

    int mbs, const void *pn)

{

	int flag = PATHMATCH_NO_ANCHOR_END;

	int r;

	if (mbs) {

		const char *p;

		r = archive_mstring_get_mbs(&(a->archive), &(m->pattern), &p);

		if (r == 0)

			return (archive_pathmatch(p, (const char *)pn, flag));

	} else {

		const wchar_t *p;

		r = archive_mstring_get_wcs(&(a->archive), &(m->pattern), &p);

		if (r == 0)

			return (archive_pathmatch_w(p, (const wchar_t *)pn,

				flag));

	}

	if (errno == ENOMEM)

		return (error_nomem(a));

	return (0);

}

static void

match_list_init(struct match_list *list)

{

	list->first = NULL;

	list->last = &(list->first);

	list->count = 0;

}

static void

match_list_free(struct match_list *list)

{

	struct match *p, *q;

	for (p = list->first; p != NULL; ) {

		q = p;

		p = p->next;

		archive_mstring_clean(&(q->pattern));

		free(q);

	}

}

static void

match_list_add(struct match_list *list, struct match *m)

{

	*list->last = m;

	list->last = &(m->next);

	list->count++;

	list->unmatched_count++;

}

static int

match_list_unmatched_inclusions_next(struct archive_match *a,

    struct match_list *list, int mbs, const void **vp)

{

	struct match *m;

	*vp = NULL;

	if (list->unmatched_eof) {

		list->unmatched_eof = 0;

		return (ARCHIVE_EOF);

	}

	if (list->unmatched_next == NULL) {

		if (list->unmatched_count == 0)

			return (ARCHIVE_EOF);

		list->unmatched_next = list->first;

	}

	for (m = list->unmatched_next; m != NULL; m = m->next) {

		int r;

		if (m->matches)

			continue;

		if (mbs) {

			const char *p;

			r = archive_mstring_get_mbs(&(a->archive),

				&(m->pattern), &p);

			if (r < 0 && errno == ENOMEM)

				return (error_nomem(a));

			if (p == NULL)

				p = "";

			*vp = p;

		} else {

			const wchar_t *p;

			r = archive_mstring_get_wcs(&(a->archive),

				&(m->pattern), &p);

			if (r < 0 && errno == ENOMEM)

				return (error_nomem(a));

			if (p == NULL)

				p = L"";

			*vp = p;

		}

		list->unmatched_next = m->next;

		if (list->unmatched_next == NULL)

			/* To return EOF next time. */

			list->unmatched_eof = 1;

		return (ARCHIVE_OK);

	}