libarchive/archive_entry_strmode.c \
libarchive/archive_entry_xattr.c \
libarchive/archive_getdate.c \
- libarchive/archive_matching.c \
+ libarchive/archive_match.c \
libarchive/archive_options.c \
libarchive/archive_options_private.h \
libarchive/archive_pathmatch.c \
libarchive/test/test_archive_clear_error.c \
libarchive/test/test_archive_crypto.c \
libarchive/test/test_archive_getdate.c \
- libarchive/test/test_archive_matching_owner.c \
- libarchive/test/test_archive_matching_path.c \
- libarchive/test/test_archive_matching_time.c \
+ libarchive/test/test_archive_match_owner.c \
+ libarchive/test/test_archive_match_path.c \
+ libarchive/test/test_archive_match_time.c \
libarchive/test/test_archive_pathmatch.c \
libarchive/test/test_archive_read_close_twice.c \
libarchive/test/test_archive_read_close_twice_open_fd.c \
cpio->bytes_per_block = 512;
cpio->filename = NULL;
- cpio->matching = archive_matching_new();
+ cpio->matching = archive_match_new();
if (cpio->matching == NULL)
lafe_errc(1, 0, "Out of memory");
cpio->filename = cpio->argument;
break;
case 'f': /* POSIX 1997 */
- if (archive_matching_exclude_pattern(cpio->matching,
+ if (archive_match_exclude_pattern(cpio->matching,
cpio->argument) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(cpio->matching));
break;
case 'i':
while (*cpio->argv != NULL) {
- if (archive_matching_include_pattern(cpio->matching,
+ if (archive_match_include_pattern(cpio->matching,
*cpio->argv) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(cpio->matching));
"Must specify at least one of -i, -o, or -p");
}
- archive_matching_free(cpio->matching);
+ archive_match_free(cpio->matching);
free_cache(cpio->gname_cache);
free_cache(cpio->uname_cache);
return (cpio->return_value);
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
- if (archive_matching_path_excluded(cpio->matching, entry))
+ if (archive_match_path_excluded(cpio->matching, entry))
continue;
if (cpio->option_rename) {
destpath = cpio_rename(archive_entry_pathname(entry));
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
- if (archive_matching_path_excluded(cpio->matching, entry))
+ if (archive_match_path_excluded(cpio->matching, entry))
continue;
if (cpio->verbose)
list_item_verbose(cpio, entry);
archive_entry_strmode.c
archive_entry_xattr.c
archive_getdate.c
- archive_matching.c
+ archive_match.c
archive_options.c
archive_options_private.h
archive_pathmatch.c
int flags);
/*
- * Set archive_matching object that will be used in archive_read_disk to
+ * Set archive_match object that will be used in archive_read_disk to
* know whether an entry should be skipped. The callback function
* _excluded_func will be invoked when an entry is skipped by the result
- * of archive_matching.
+ * of archive_match.
*/
__LA_DECL int archive_read_disk_set_matching(struct archive *,
struct archive *_matching, void (*_excluded_func)
__LA_DECL int archive_file_count(struct archive *);
/*
- * ARCHIVE_MATCHING API
+ * ARCHIVE_MATCH API
*/
-__LA_DECL struct archive *archive_matching_new(void);
-__LA_DECL int archive_matching_free(struct archive *);
+__LA_DECL struct archive *archive_match_new(void);
+__LA_DECL int archive_match_free(struct archive *);
/*
* Test if archive_entry is excluded.
* This is a convenience function. This is the same as calling all
- * archive_matching_path_excluded, archive_matching_time_excluded
- * and archive_matching_owner_excluded.
+ * archive_match_path_excluded, archive_match_time_excluded
+ * and archive_match_owner_excluded.
*/
-__LA_DECL int archive_matching_excluded(struct archive *,
+__LA_DECL int archive_match_excluded(struct archive *,
struct archive_entry *);
/*
* Test if pathname is excluded. The conditions are set by following functions.
*/
-__LA_DECL int archive_matching_path_excluded(struct archive *,
+__LA_DECL int archive_match_path_excluded(struct archive *,
struct archive_entry *);
/* Add exclusion pathname pattern. */
-__LA_DECL int archive_matching_exclude_pattern(struct archive *,
- const char *);
-__LA_DECL int archive_matching_exclude_pattern_w(struct archive *,
+__LA_DECL int archive_match_exclude_pattern(struct archive *, const char *);
+__LA_DECL int archive_match_exclude_pattern_w(struct archive *,
const wchar_t *);
/* Add inclusion pathname pattern. */
-__LA_DECL int archive_matching_include_pattern(struct archive *,
- const char *);
-__LA_DECL int archive_matching_include_pattern_w(struct archive *,
+__LA_DECL int archive_match_include_pattern(struct archive *, const char *);
+__LA_DECL int archive_match_include_pattern_w(struct archive *,
const wchar_t *);
/*
* How to get statistic information for inclusion patterns.
*/
/* Return the amount number of unmatched inclusion patterns. */
-__LA_DECL int archive_matching_path_unmatched_inclusions(
- struct archive *);
+__LA_DECL int archive_match_path_unmatched_inclusions(struct archive *);
/* Return the pattern of unmatched inclusion with ARCHIVE_OK.
* Return ARCHIVE_EOF if there is no inclusion pattern. */
-__LA_DECL int archive_matching_path_unmatched_inclusions_next(
+__LA_DECL int archive_match_path_unmatched_inclusions_next(
struct archive *, const char **);
-__LA_DECL int archive_matching_path_unmatched_inclusions_next_w(
+__LA_DECL int archive_match_path_unmatched_inclusions_next_w(
struct archive *, const wchar_t **);
/*
* Test if a file is excluded by its time stamp.
* The conditions are set by following functions.
*/
-__LA_DECL int archive_matching_time_excluded(struct archive *,
+__LA_DECL int archive_match_time_excluded(struct archive *,
struct archive_entry *);
/*
* Flags to tell a matching type of time stamps. These are used for
- * following functinos archive_matching_time*().
+ * following functinos.
*/
/* Time flag: mtime to be tested. */
-#define ARCHIVE_MATCHING_MTIME (0x0100)
+#define ARCHIVE_MATCH_MTIME (0x0100)
/* Time flag: ctime to be tested. */
-#define ARCHIVE_MATCHING_CTIME (0x0200)
+#define ARCHIVE_MATCH_CTIME (0x0200)
/* Comparison flag: Match the time if it is newer than. */
-#define ARCHIVE_MATCHING_NEWER (0x0001)
+#define ARCHIVE_MATCH_NEWER (0x0001)
/* Comparison flag: Match the time if it is older than. */
-#define ARCHIVE_MATCHING_OLDER (0x0002)
+#define ARCHIVE_MATCH_OLDER (0x0002)
/* Comparison flag: Match the time if it is equal to. */
-#define ARCHIVE_MATCHING_EQUAL (0x0010)
+#define ARCHIVE_MATCH_EQUAL (0x0010)
/* Set inclusion time. */
-__LA_DECL int archive_matching_include_time(struct archive *, int _flag,
+__LA_DECL int archive_match_include_time(struct archive *, int _flag,
time_t _sec, long _nsec);
/* Set inclusion time by a date string. */
-__LA_DECL int archive_matching_include_date(struct archive *, int _flag,
+__LA_DECL int archive_match_include_date(struct archive *, int _flag,
const char *_datestr);
-__LA_DECL int archive_matching_include_date_w(struct archive *, int _flag,
+__LA_DECL int archive_match_include_date_w(struct archive *, int _flag,
const wchar_t *_datestr);
/* Set inclusion time by a particluar file. */
-__LA_DECL int archive_matching_include_time_pathname(struct archive *,
+__LA_DECL int archive_match_include_file_time(struct archive *,
int _flag, const char *_pathname);
-__LA_DECL int archive_matching_include_time_pathname_w(struct archive *,
+__LA_DECL int archive_match_include_file_time_w(struct archive *,
int _flag, const wchar_t *_pathname);
/* Add exclusion entry. */
-__LA_DECL int archive_matching_exclude_entry(struct archive *,
+__LA_DECL int archive_match_exclude_entry(struct archive *,
int _flag, struct archive_entry *);
/*
* Test if a file is excluded by its uid ,gid, uname or gname.
* The conditions are set by following functions.
*/
-__LA_DECL int archive_matching_owner_excluded(struct archive *,
+__LA_DECL int archive_match_owner_excluded(struct archive *,
struct archive_entry *);
/* Add inclusion uid, gid, uname and gname. */
-__LA_DECL int archive_matching_include_uid(struct archive *,
- int64_t);
-__LA_DECL int archive_matching_include_gid(struct archive *,
- int64_t);
-__LA_DECL int archive_matching_include_uname(struct archive *,
- const char *);
-__LA_DECL int archive_matching_include_uname_w(struct archive *,
+__LA_DECL int archive_match_include_uid(struct archive *, int64_t);
+__LA_DECL int archive_match_include_gid(struct archive *, int64_t);
+__LA_DECL int archive_match_include_uname(struct archive *, const char *);
+__LA_DECL int archive_match_include_uname_w(struct archive *,
const wchar_t *);
-__LA_DECL int archive_matching_include_gname(struct archive *,
- const char *);
-__LA_DECL int archive_matching_include_gname_w(struct archive *,
+__LA_DECL int archive_match_include_gname(struct archive *, const char *);
+__LA_DECL int archive_match_include_gname_w(struct archive *,
const wchar_t *);
#ifdef __cplusplus
case ARCHIVE_READ_MAGIC: return ("archive_read");
case ARCHIVE_WRITE_DISK_MAGIC: return ("archive_write_disk");
case ARCHIVE_READ_DISK_MAGIC: return ("archive_read_disk");
- case ARCHIVE_MATCHING_MAGIC: return ("archive_matching");
+ case ARCHIVE_MATCH_MAGIC: return ("archive_match");
default: return NULL;
}
}
#define TIME_IS_SET 2
#define ID_IS_SET 4
-struct archive_matching {
+struct archive_match {
struct archive archive;
/* exclusion/inclusion set flag. */
struct match_list inclusion_gnames;
};
-static int add_entry(struct archive_matching *, int,
+static int add_entry(struct archive_match *, int,
struct archive_entry *);
-static int add_owner_id(struct archive_matching *, struct id_array *,
+static int add_owner_id(struct archive_match *, struct id_array *,
int64_t);
-static int add_owner_name(struct archive_matching *, struct match_list *,
+static int add_owner_name(struct archive_match *, struct match_list *,
int, const void *);
-static int add_pattern_mbs(struct archive_matching *, struct match_list *,
+static int add_pattern_mbs(struct archive_match *, struct match_list *,
const char *);
-static int add_pattern_wcs(struct archive_matching *, struct match_list *,
+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 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_matching *);
+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_matching *,
+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_matching *,
+static int match_owner_name_mbs(struct archive_match *,
struct match_list *, const char *);
#else
-static int match_owner_name_wcs(struct archive_matching *,
+static int match_owner_name_wcs(struct archive_match *,
struct match_list *, const wchar_t *);
#endif
-static int match_path_exclusion(struct archive_matching *,
+static int match_path_exclusion(struct archive_match *,
struct match *, int, const void *);
-static int match_path_inclusion(struct archive_matching *,
+static int match_path_inclusion(struct archive_match *,
struct match *, int, const void *);
-static int owner_excluded(struct archive_matching *,
+static int owner_excluded(struct archive_match *,
struct archive_entry *);
-static int path_excluded(struct archive_matching *, int, const void *);
-static int set_timefilter(struct archive_matching *, int, time_t, long,
+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_matching *,
+static int set_timefilter_pathname_mbs(struct archive_match *,
int, const char *);
-static int set_timefilter_pathname_wcs(struct archive_matching *,
+static int set_timefilter_pathname_wcs(struct archive_match *,
int, const wchar_t *);
-static int set_time_str(struct archive_matching *, int, const char *);
-static int set_time_str_w(struct archive_matching *, int, const wchar_t *);
-static int time_excluded(struct archive_matching *,
+static int set_time_str(struct archive_match *, int, const char *);
+static int set_time_str_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 *);
*/
static int
-error_nomem(struct archive_matching *a)
+error_nomem(struct archive_match *a)
{
archive_set_error(&(a->archive), ENOMEM, "No memory");
a->archive.state = ARCHIVE_STATE_FATAL;
}
struct archive *
-archive_matching_new(void)
+archive_match_new(void)
{
- struct archive_matching *a;
+ struct archive_match *a;
- a = (struct archive_matching *)calloc(1, sizeof(*a));
+ a = (struct archive_match *)calloc(1, sizeof(*a));
if (a == NULL)
return (NULL);
- a->archive.magic = ARCHIVE_MATCHING_MAGIC;
+ a->archive.magic = ARCHIVE_MATCH_MAGIC;
a->archive.state = ARCHIVE_STATE_NEW;
match_list_init(&(a->inclusions));
match_list_init(&(a->exclusions));
}
int
-archive_matching_free(struct archive *_a)
+archive_match_free(struct archive *_a)
{
- struct archive_matching *a;
+ struct archive_match *a;
if (_a == NULL)
return (ARCHIVE_OK);
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_matching_free");
- a = (struct archive_matching *)_a;
+ 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->entry_list));
* Returns <0 if something error happened.
*/
int
-archive_matching_excluded(struct archive *_a, struct archive_entry *entry)
+archive_match_excluded(struct archive *_a, struct archive_entry *entry)
{
- struct archive_matching *a;
+ struct archive_match *a;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_excluded_ae");
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_excluded_ae");
- a = (struct archive_matching *)_a;
+ a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
*/
int
-archive_matching_exclude_pattern(struct archive *_a, const char *pattern)
+archive_match_exclude_pattern(struct archive *_a, const char *pattern)
{
- struct archive_matching *a;
+ struct archive_match *a;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_exclude_pattern");
- a = (struct archive_matching *)_a;
+ 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");
}
int
-archive_matching_exclude_pattern_w(struct archive *_a, const wchar_t *pattern)
+archive_match_exclude_pattern_w(struct archive *_a, const wchar_t *pattern)
{
- struct archive_matching *a;
+ struct archive_match *a;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_exclude_pattern_w");
- a = (struct archive_matching *)_a;
+ 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");
}
int
-archive_matching_include_pattern(struct archive *_a, const char *pattern)
+archive_match_include_pattern(struct archive *_a, const char *pattern)
{
- struct archive_matching *a;
+ struct archive_match *a;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_pattern");
- a = (struct archive_matching *)_a;
+ 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");
}
int
-archive_matching_include_pattern_w(struct archive *_a, const wchar_t *pattern)
+archive_match_include_pattern_w(struct archive *_a, const wchar_t *pattern)
{
- struct archive_matching *a;
+ struct archive_match *a;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_pattern_w");
- a = (struct archive_matching *)_a;
+ 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");
* Returns <0 if something error happened.
*/
int
-archive_matching_path_excluded(struct archive *_a,
+archive_match_path_excluded(struct archive *_a,
struct archive_entry *entry)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_path_excluded");
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_path_excluded");
- a = (struct archive_matching *)_a;
+ a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
* Utilty functions to get statistic information for inclusion patterns.
*/
int
-archive_matching_path_unmatched_inclusions(struct archive *_a)
+archive_match_path_unmatched_inclusions(struct archive *_a)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_unmatched_inclusions");
- a = (struct archive_matching *)_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_matching_path_unmatched_inclusions_next(struct archive *_a,
+archive_match_path_unmatched_inclusions_next(struct archive *_a,
const char **_p)
{
- struct archive_matching *a;
+ struct archive_match *a;
const void *v;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_unmatched_inclusions_next");
- a = (struct archive_matching *)_a;
+ 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;
}
int
-archive_matching_path_unmatched_inclusions_next_w(struct archive *_a,
+archive_match_path_unmatched_inclusions_next_w(struct archive *_a,
const wchar_t **_p)
{
- struct archive_matching *a;
+ struct archive_match *a;
const void *v;
int r;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_unmatched_inclusions_next_w");
- a = (struct archive_matching *)_a;
+ 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;
}
static int
-add_pattern_mbs(struct archive_matching *a, struct match_list *list,
+add_pattern_mbs(struct archive_match *a, struct match_list *list,
const char *pattern)
{
struct match *match;
}
static int
-add_pattern_wcs(struct archive_matching *a, struct match_list *list,
+add_pattern_wcs(struct archive_match *a, struct match_list *list,
const wchar_t *pattern)
{
struct match *match;
}
static int
-path_excluded(struct archive_matching *a, int mbs, const void *pathname)
+path_excluded(struct archive_match *a, int mbs, const void *pathname)
{
struct match *match;
struct match *matched;
*
*/
static int
-match_path_exclusion(struct archive_matching *a, struct match *m,
+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;
* the beginning of the path) even though exclusions are not anchored.
*/
static int
-match_path_inclusion(struct archive_matching *a, struct match *m,
+match_path_inclusion(struct archive_match *a, struct match *m,
int mbs, const void *pn)
{
int flag = PATHMATCH_NO_ANCHOR_END;
}
static int
-match_list_unmatched_inclusions_next(struct archive_matching *a,
+match_list_unmatched_inclusions_next(struct archive_match *a,
struct match_list *list, int mbs, const void **vp)
{
struct match *m;
* Utility functions to manage inclusion timestamps.
*/
int
-archive_matching_include_time(struct archive *_a, int flag, time_t sec,
+archive_match_include_time(struct archive *_a, int flag, time_t sec,
long nsec)
{
int r;
- r = validate_time_flag(_a, flag, "archive_matching_include_time");
+ r = validate_time_flag(_a, flag, "archive_match_include_time");
if (r != ARCHIVE_OK)
return (r);
- return set_timefilter((struct archive_matching *)_a, flag,
+ return set_timefilter((struct archive_match *)_a, flag,
sec, nsec, sec, nsec);
}
int
-archive_matching_include_date(struct archive *_a, int flag,
+archive_match_include_date(struct archive *_a, int flag,
const char *datestr)
{
int r;
- r = validate_time_flag(_a, flag, "archive_matching_include_date");
+ r = validate_time_flag(_a, flag, "archive_match_include_date");
if (r != ARCHIVE_OK)
return (r);
- return set_time_str((struct archive_matching *)_a, flag, datestr);
+ return set_time_str((struct archive_match *)_a, flag, datestr);
}
int
-archive_matching_include_date_w(struct archive *_a, int flag,
+archive_match_include_date_w(struct archive *_a, int flag,
const wchar_t *datestr)
{
int r;
- r = validate_time_flag(_a, flag, "archive_matching_include_date_w");
+ r = validate_time_flag(_a, flag, "archive_match_include_date_w");
if (r != ARCHIVE_OK)
return (r);
- return set_time_str_w((struct archive_matching *)_a, flag, datestr);
+ return set_time_str_w((struct archive_match *)_a, flag, datestr);
}
int
-archive_matching_include_time_pathname(struct archive *_a, int flag,
+archive_match_include_file_time(struct archive *_a, int flag,
const char *pathname)
{
int r;
- r = validate_time_flag(_a, flag,
- "archive_matching_include_time_pathname");
+ r = validate_time_flag(_a, flag, "archive_match_include_file_time");
if (r != ARCHIVE_OK)
return (r);
- return set_timefilter_pathname_mbs((struct archive_matching *)_a,
+ return set_timefilter_pathname_mbs((struct archive_match *)_a,
flag, pathname);
}
int
-archive_matching_include_time_pathname_w(struct archive *_a, int flag,
+archive_match_include_file_time_w(struct archive *_a, int flag,
const wchar_t *pathname)
{
int r;
- r = validate_time_flag(_a, flag,
- "archive_matching_include_time_pathname_w");
+ r = validate_time_flag(_a, flag, "archive_match_include_file_time_w");
if (r != ARCHIVE_OK)
return (r);
- return set_timefilter_pathname_wcs((struct archive_matching *)_a,
+ return set_timefilter_pathname_wcs((struct archive_match *)_a,
flag, pathname);
}
int
-archive_matching_exclude_entry(struct archive *_a, int flag,
+archive_match_exclude_entry(struct archive *_a, int flag,
struct archive_entry *entry)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_time_include_entry");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_time_include_entry");
+ a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
* Returns <0 if something error happened.
*/
int
-archive_matching_time_excluded(struct archive *_a,
+archive_match_time_excluded(struct archive *_a,
struct archive_entry *entry)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_time_excluded_ae");
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_time_excluded_ae");
- a = (struct archive_matching *)_a;
+ a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
static int
validate_time_flag(struct archive *_a, int flag, const char *_fn)
{
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, _fn);
/* Check a type of time. */
if (flag &
- ((~(ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME)) & 0xff00)) {
+ ((~(ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME)) & 0xff00)) {
archive_set_error(_a, EINVAL, "Invalid time flag");
return (ARCHIVE_FAILED);
}
- if ((flag & (ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME)) == 0) {
+ if ((flag & (ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME)) == 0) {
archive_set_error(_a, EINVAL, "No time flag");
return (ARCHIVE_FAILED);
}
/* Check a type of comparison. */
if (flag &
- ((~(ARCHIVE_MATCHING_NEWER | ARCHIVE_MATCHING_OLDER
- | ARCHIVE_MATCHING_EQUAL)) & 0x00ff)) {
+ ((~(ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_OLDER
+ | ARCHIVE_MATCH_EQUAL)) & 0x00ff)) {
archive_set_error(_a, EINVAL, "Invalid comparison flag");
return (ARCHIVE_FAILED);
}
- if ((flag & (ARCHIVE_MATCHING_NEWER | ARCHIVE_MATCHING_OLDER
- | ARCHIVE_MATCHING_EQUAL)) == 0) {
+ if ((flag & (ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_OLDER
+ | ARCHIVE_MATCH_EQUAL)) == 0) {
archive_set_error(_a, EINVAL, "No comparison flag");
return (ARCHIVE_FAILED);
}
return (ARCHIVE_OK);
}
-#define JUST_EQUAL(t) (((t) & (ARCHIVE_MATCHING_EQUAL |\
- ARCHIVE_MATCHING_NEWER | ARCHIVE_MATCHING_OLDER))\
- == ARCHIVE_MATCHING_EQUAL)
+#define JUST_EQUAL(t) (((t) & (ARCHIVE_MATCH_EQUAL |\
+ ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_OLDER)) == ARCHIVE_MATCH_EQUAL)
static int
-set_timefilter(struct archive_matching *a, int timetype,
+set_timefilter(struct archive_match *a, int timetype,
time_t mtime_sec, long mtime_nsec, time_t ctime_sec, long ctime_nsec)
{
- if (timetype & ARCHIVE_MATCHING_MTIME) {
- if ((timetype & ARCHIVE_MATCHING_NEWER) ||
+ if (timetype & ARCHIVE_MATCH_MTIME) {
+ if ((timetype & ARCHIVE_MATCH_NEWER) ||
JUST_EQUAL(timetype)) {
a->newer_mtime_filter = timetype;
a->newer_mtime_sec = mtime_sec;
a->newer_mtime_nsec = mtime_nsec;
a->setflag |= TIME_IS_SET;
}
- if (timetype & ARCHIVE_MATCHING_OLDER) {
+ if (timetype & ARCHIVE_MATCH_OLDER) {
a->older_mtime_filter = timetype;
a->older_mtime_sec = mtime_sec;
a->older_mtime_nsec = mtime_nsec;
a->setflag |= TIME_IS_SET;
}
}
- if (timetype & ARCHIVE_MATCHING_CTIME) {
- if ((timetype & ARCHIVE_MATCHING_NEWER) ||
+ if (timetype & ARCHIVE_MATCH_CTIME) {
+ if ((timetype & ARCHIVE_MATCH_NEWER) ||
JUST_EQUAL(timetype)) {
a->newer_ctime_filter = timetype;
a->newer_ctime_sec = ctime_sec;
a->newer_ctime_nsec = ctime_nsec;
a->setflag |= TIME_IS_SET;
}
- if (timetype & ARCHIVE_MATCHING_OLDER) {
+ if (timetype & ARCHIVE_MATCH_OLDER) {
a->older_ctime_filter = timetype;
a->older_ctime_sec = ctime_sec;
a->older_ctime_nsec = ctime_nsec;
}
static int
-set_time_str(struct archive_matching *a, int timetype, const char *datestr)
+set_time_str(struct archive_match *a, int timetype, const char *datestr)
{
time_t time;
}
static int
-set_time_str_w(struct archive_matching *a, int timetype, const wchar_t *datestr)
+set_time_str_w(struct archive_match *a, int timetype, const wchar_t *datestr)
{
struct archive_string as;
time_t time;
#if defined(_WIN32) && !defined(__CYGWIN__)
#define EPOC_TIME (116444736000000000ui64)
static int
-set_timefilter_find_data(struct archive_matching *a, int timetype,
+set_timefilter_find_data(struct archive_match *a, int timetype,
DWORD ftLastWriteTime_dwHighDateTime, DWORD ftLastWriteTime_dwLowDateTime,
DWORD ftCreationTime_dwHighDateTime, DWORD ftCreationTime_dwLowDateTime)
{
}
#else
static int
-set_timefilter_stat(struct archive_matching *a, int timetype, struct stat *st)
+set_timefilter_stat(struct archive_match *a, int timetype, struct stat *st)
{
struct archive_entry *ae;
time_t ctime, mtime;
#endif
static int
-set_timefilter_pathname_mbs(struct archive_matching *a, int timetype,
+set_timefilter_pathname_mbs(struct archive_match *a, int timetype,
const char *path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
}
static int
-set_timefilter_pathname_wcs(struct archive_matching *a, int timetype,
+set_timefilter_pathname_wcs(struct archive_match *a, int timetype,
const wchar_t *path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
}
static int
-add_entry(struct archive_matching *a, int flag,
+add_entry(struct archive_match *a, int flag,
struct archive_entry *entry)
{
struct match_file *f;
}
static int
-time_excluded(struct archive_matching *a, struct archive_entry *entry)
+time_excluded(struct archive_match *a, struct archive_entry *entry)
{
struct match_file *f;
const void *pathname;
if (nsec < a->newer_ctime_nsec)
return (1); /* Too old, skip it. */
if (nsec == a->newer_ctime_nsec &&
- (a->newer_ctime_filter & ARCHIVE_MATCHING_EQUAL)
+ (a->newer_ctime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
} else if (JUST_EQUAL(a->newer_ctime_filter))
if (nsec > a->older_ctime_nsec)
return (1); /* Too new, skip it. */
if (nsec == a->older_ctime_nsec &&
- (a->older_ctime_filter & ARCHIVE_MATCHING_EQUAL)
+ (a->older_ctime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Eeual, skip it. */
}
if (nsec < a->newer_mtime_nsec)
return (1); /* Too old, skip it. */
if (nsec == a->newer_mtime_nsec &&
- (a->newer_mtime_filter & ARCHIVE_MATCHING_EQUAL)
+ (a->newer_mtime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
} else if (JUST_EQUAL(a->newer_mtime_filter))
if (nsec > a->older_mtime_nsec)
return (1); /* Too new, skip it. */
if (nsec == a->older_mtime_nsec &&
- (a->older_mtime_filter & ARCHIVE_MATCHING_EQUAL)
+ (a->older_mtime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
}
if (f == NULL)
return (0);
- if (f->flag & ARCHIVE_MATCHING_CTIME) {
+ if (f->flag & ARCHIVE_MATCH_CTIME) {
sec = archive_entry_ctime(entry);
if (f->ctime_sec > sec) {
- if (f->flag & ARCHIVE_MATCHING_OLDER)
+ if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->ctime_sec < sec) {
- if (f->flag & ARCHIVE_MATCHING_NEWER)
+ if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else {
nsec = archive_entry_ctime_nsec(entry);
if (f->ctime_nsec > nsec) {
- if (f->flag & ARCHIVE_MATCHING_OLDER)
+ if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->ctime_nsec < nsec) {
- if (f->flag & ARCHIVE_MATCHING_NEWER)
+ if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
- } else if (f->flag & ARCHIVE_MATCHING_EQUAL)
+ } else if (f->flag & ARCHIVE_MATCH_EQUAL)
return (1);
}
}
- if (f->flag & ARCHIVE_MATCHING_MTIME) {
+ if (f->flag & ARCHIVE_MATCH_MTIME) {
sec = archive_entry_mtime(entry);
if (f->mtime_sec > sec) {
- if (f->flag & ARCHIVE_MATCHING_OLDER)
+ if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->mtime_sec < sec) {
- if (f->flag & ARCHIVE_MATCHING_NEWER)
+ if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else {
nsec = archive_entry_mtime_nsec(entry);
if (f->mtime_nsec > nsec) {
- if (f->flag & ARCHIVE_MATCHING_OLDER)
+ if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->mtime_nsec < nsec) {
- if (f->flag & ARCHIVE_MATCHING_NEWER)
+ if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
- } else if (f->flag & ARCHIVE_MATCHING_EQUAL)
+ } else if (f->flag & ARCHIVE_MATCH_EQUAL)
return (1);
}
}
*/
int
-archive_matching_include_uid(struct archive *_a, int64_t uid)
+archive_match_include_uid(struct archive *_a, int64_t uid)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_uid");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_uid");
+ a = (struct archive_match *)_a;
return (add_owner_id(a, &(a->inclusion_uids), uid));
}
int
-archive_matching_include_gid(struct archive *_a, int64_t gid)
+archive_match_include_gid(struct archive *_a, int64_t gid)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_gid");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_gid");
+ a = (struct archive_match *)_a;
return (add_owner_id(a, &(a->inclusion_gids), gid));
}
int
-archive_matching_include_uname(struct archive *_a, const char *uname)
+archive_match_include_uname(struct archive *_a, const char *uname)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_uname");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_uname");
+ a = (struct archive_match *)_a;
return (add_owner_name(a, &(a->inclusion_unames), 1, uname));
}
int
-archive_matching_include_uname_w(struct archive *_a, const wchar_t *uname)
+archive_match_include_uname_w(struct archive *_a, const wchar_t *uname)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_uname_w");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_uname_w");
+ a = (struct archive_match *)_a;
return (add_owner_name(a, &(a->inclusion_unames), 0, uname));
}
int
-archive_matching_include_gname(struct archive *_a, const char *gname)
+archive_match_include_gname(struct archive *_a, const char *gname)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_gname");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_gname");
+ a = (struct archive_match *)_a;
return (add_owner_name(a, &(a->inclusion_gnames), 1, gname));
}
int
-archive_matching_include_gname_w(struct archive *_a, const wchar_t *gname)
+archive_match_include_gname_w(struct archive *_a, const wchar_t *gname)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_include_gname_w");
- a = (struct archive_matching *)_a;
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_include_gname_w");
+ a = (struct archive_match *)_a;
return (add_owner_name(a, &(a->inclusion_gnames), 0, gname));
}
* Returns <0 if something error happened.
*/
int
-archive_matching_owner_excluded(struct archive *_a,
+archive_match_owner_excluded(struct archive *_a,
struct archive_entry *entry)
{
- struct archive_matching *a;
+ struct archive_match *a;
- archive_check_magic(_a, ARCHIVE_MATCHING_MAGIC,
- ARCHIVE_STATE_NEW, "archive_matching_id_excluded_ae");
+ archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
+ ARCHIVE_STATE_NEW, "archive_match_id_excluded_ae");
- a = (struct archive_matching *)_a;
+ a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
}
static int
-add_owner_id(struct archive_matching *a, struct id_array *ids, int64_t id)
+add_owner_id(struct archive_match *a, struct id_array *ids, int64_t id)
{
if (ids->count + 1 >= ids->size) {
if (ids->size == 0)
}
static int
-add_owner_name(struct archive_matching *a, struct match_list *list,
+add_owner_name(struct archive_match *a, struct match_list *list,
int mbs, const void *name)
{
struct match *match;
#if !defined(_WIN32) || defined(__CYGWIN__)
static int
-match_owner_name_mbs(struct archive_matching *a, struct match_list *list,
+match_owner_name_mbs(struct archive_match *a, struct match_list *list,
const char *name)
{
struct match *m;
}
#else
static int
-match_owner_name_wcs(struct archive_matching *a, struct match_list *list,
+match_owner_name_wcs(struct archive_match *a, struct match_list *list,
const wchar_t *name)
{
struct match *m;
#endif
static int
-owner_excluded(struct archive_matching *a, struct archive_entry *entry)
+owner_excluded(struct archive_match *a, struct archive_entry *entry)
{
int r;
#define ARCHIVE_READ_MAGIC (0xdeb0c5U)
#define ARCHIVE_WRITE_DISK_MAGIC (0xc001b0c5U)
#define ARCHIVE_READ_DISK_MAGIC (0xbadb0c5U)
-#define ARCHIVE_MATCHING_MAGIC (0xcad11c9U)
+#define ARCHIVE_MATCH_MAGIC (0xcad11c9U)
#define ARCHIVE_STATE_NEW 1U
#define ARCHIVE_STATE_HEADER 2U
* Perform path matching.
*/
if (a->matching) {
- r = archive_matching_path_excluded(a->matching, entry);
+ r = archive_match_path_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
* Perform time matching.
*/
if (a->matching) {
- r = archive_matching_time_excluded(a->matching, entry);
+ r = archive_match_time_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
* Perform owner matching.
*/
if (a->matching) {
- r = archive_matching_owner_excluded(a->matching, entry);
+ r = archive_match_owner_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
struct archive_entry *);
void *metadata_filter_data;
- /* ARCHIVE_MATCHING object. */
+ /* ARCHIVE_MATCH object. */
struct archive *matching;
- /* Callback function, this will be invoked when ARCHIVE_MATCHING
- * archive_matching_*_excluded_ae return true. */
+ /* Callback function, this will be invoked when ARCHIVE_MATCH
+ * archive_match_*_excluded_ae return true. */
void (*excluded_cb_func)(struct archive *, void *,
struct archive_entry *);
void *excluded_cb_data;
* Perform path matching.
*/
if (a->matching) {
- r = archive_matching_path_excluded(a->matching, entry);
+ r = archive_match_path_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
* Perform time matching.
*/
if (a->matching) {
- r = archive_matching_time_excluded(a->matching, entry);
+ r = archive_match_time_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
* Perform owner matching.
*/
if (a->matching) {
- r = archive_matching_owner_excluded(a->matching, entry);
+ r = archive_match_owner_excluded(a->matching, entry);
if (r < 0) {
archive_set_error(&(a->archive), errno,
"Faild : %s", archive_error_string(a->matching));
test_archive_clear_error.c
test_archive_crypto.c
test_archive_getdate.c
- test_archive_matching_owner.c
- test_archive_matching_path.c
- test_archive_matching_time.c
+ test_archive_match_owner.c
+ test_archive_match_path.c
+ test_archive_match_time.c
test_archive_pathmatch.c
test_archive_read_close_twice.c
test_archive_read_close_twice_open_fd.c
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_uid(m, 1000));
- assertEqualIntA(m, 0, archive_matching_include_uid(m, 1002));
+ assertEqualIntA(m, 0, archive_match_include_uid(m, 1000));
+ assertEqualIntA(m, 0, archive_match_include_uid(m, 1002));
archive_entry_set_uid(ae, 0);
failure("uid 0 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_uid(ae, 1000);
failure("uid 1000 should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_uid(ae, 1001);
failure("uid 1001 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_uid(ae, 1002);
failure("uid 1002 should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_uid(ae, 1003);
failure("uid 1003 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_gid(m, 1000));
- assertEqualIntA(m, 0, archive_matching_include_gid(m, 1002));
+ assertEqualIntA(m, 0, archive_match_include_gid(m, 1000));
+ assertEqualIntA(m, 0, archive_match_include_gid(m, 1002));
archive_entry_set_gid(ae, 0);
failure("uid 0 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_gid(ae, 1000);
failure("uid 1000 should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_gid(ae, 1001);
failure("uid 1001 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_gid(ae, 1002);
failure("uid 1002 should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_gid(ae, 1003);
failure("uid 1003 should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_uname(m, "foo"));
- assertEqualIntA(m, 0, archive_matching_include_uname(m, "bar"));
+ assertEqualIntA(m, 0, archive_match_include_uname(m, "foo"));
+ assertEqualIntA(m, 0, archive_match_include_uname(m, "bar"));
archive_entry_copy_uname(ae, "unknown");
failure("User 'unknown' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_uname(ae, "foo");
failure("User 'foo' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_uname(ae, "foo1");
failure("User 'foo1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_uname(ae, "bar");
failure("User 'bar' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_uname(ae, "bar1");
failure("User 'bar1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_uname_w(m, L"foo"));
- assertEqualIntA(m, 0, archive_matching_include_uname_w(m, L"bar"));
+ assertEqualIntA(m, 0, archive_match_include_uname_w(m, L"foo"));
+ assertEqualIntA(m, 0, archive_match_include_uname_w(m, L"bar"));
archive_entry_copy_uname_w(ae, L"unknown");
failure("User 'unknown' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_uname_w(ae, L"foo");
failure("User 'foo' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_uname_w(ae, L"foo1");
failure("User 'foo1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_uname_w(ae, L"bar");
failure("User 'bar' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_uname_w(ae, L"bar1");
failure("User 'bar1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_gname(m, "foo"));
- assertEqualIntA(m, 0, archive_matching_include_gname(m, "bar"));
+ assertEqualIntA(m, 0, archive_match_include_gname(m, "foo"));
+ assertEqualIntA(m, 0, archive_match_include_gname(m, "bar"));
archive_entry_copy_gname(ae, "unknown");
failure("Group 'unknown' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_gname(ae, "foo");
failure("Group 'foo' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_gname(ae, "foo1");
failure("Group 'foo1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_gname(ae, "bar");
failure("Group 'bar' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_gname(ae, "bar1");
failure("Group 'bar1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_gname_w(m, L"foo"));
- assertEqualIntA(m, 0, archive_matching_include_gname_w(m, L"bar"));
+ assertEqualIntA(m, 0, archive_match_include_gname_w(m, L"foo"));
+ assertEqualIntA(m, 0, archive_match_include_gname_w(m, L"bar"));
archive_entry_copy_gname_w(ae, L"unknown");
failure("Group 'unknown' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_gname_w(ae, L"foo");
failure("Group 'foo' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_gname_w(ae, L"foo1");
failure("Group 'foo1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_copy_gname_w(ae, L"bar");
failure("Group 'bar' should not be excluded");
- assertEqualInt(0, archive_matching_owner_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_owner_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_gname_w(ae, L"bar1");
failure("Group 'bar1' should be excluded");
- assertEqualInt(1, archive_matching_owner_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_owner_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
-DEFINE_TEST(test_archive_matching_owner)
+DEFINE_TEST(test_archive_match_owner)
{
test_uid();
test_gid();
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
/* Test for pattern "^aa*" */
- assertEqualIntA(m, 0, archive_matching_exclude_pattern(m, "^aa*"));
+ assertEqualIntA(m, 0, archive_match_exclude_pattern(m, "^aa*"));
/* Test with 'aa1234', which should be excluded. */
archive_entry_copy_pathname(ae, "aa1234");
failure("'aa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aa1234");
failure("'aa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test with 'a1234', which should not be excluded. */
archive_entry_copy_pathname(ae, "a1234");
failure("'a1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"a1234");
failure("'a1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
/* Test for pattern "^aa*" */
- assertEqualIntA(m, 0, archive_matching_exclude_pattern_w(m, L"^aa*"));
+ assertEqualIntA(m, 0, archive_match_exclude_pattern_w(m, L"^aa*"));
/* Test with 'aa1234', which should be excluded. */
archive_entry_copy_pathname(ae, "aa1234");
failure("'aa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aa1234");
failure("'aa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test with 'a1234', which should not be excluded. */
archive_entry_copy_pathname(ae, "a1234");
failure("'a1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"a1234");
failure("'a1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
const char *mp;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
/* Test for pattern "^aa*" */
- assertEqualIntA(m, 0, archive_matching_include_pattern(m, "^aa*"));
+ assertEqualIntA(m, 0, archive_match_include_pattern(m, "^aa*"));
/* Test with 'aa1234', which should not be excluded. */
archive_entry_copy_pathname(ae, "aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Test with 'a1234', which should be excluded. */
archive_entry_copy_pathname(ae, "a1234");
failure("'a1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"a1234");
failure("'a1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify unmatched_inclusions. */
- assertEqualInt(0, archive_matching_path_unmatched_inclusions(m));
+ assertEqualInt(0, archive_match_path_unmatched_inclusions(m));
assertEqualIntA(m, ARCHIVE_EOF,
- archive_matching_path_unmatched_inclusions_next(m, &mp));
+ archive_match_path_unmatched_inclusions_next(m, &mp));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
const char *mp;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
/* Test for pattern "^aa*" */
- assertEqualIntA(m, 0, archive_matching_include_pattern_w(m, L"^aa*"));
+ assertEqualIntA(m, 0, archive_match_include_pattern_w(m, L"^aa*"));
/* Test with 'aa1234', which should not be excluded. */
archive_entry_copy_pathname(ae, "aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Test with 'a1234', which should be excluded. */
archive_entry_copy_pathname(ae, "a1234");
failure("'a1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"a1234");
failure("'a1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify unmatched_inclusions. */
- assertEqualInt(0, archive_matching_path_unmatched_inclusions(m));
+ assertEqualInt(0, archive_match_path_unmatched_inclusions(m));
assertEqualIntA(m, ARCHIVE_EOF,
- archive_matching_path_unmatched_inclusions_next(m, &mp));
+ archive_match_path_unmatched_inclusions_next(m, &mp));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
const char *mp;
const wchar_t *wp;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_exclude_pattern(m, "^aaa*"));
- assertEqualIntA(m, 0, archive_matching_include_pattern_w(m, L"^aa*"));
- assertEqualIntA(m, 0, archive_matching_include_pattern(m, "^a1*"));
+ assertEqualIntA(m, 0, archive_match_exclude_pattern(m, "^aaa*"));
+ assertEqualIntA(m, 0, archive_match_include_pattern_w(m, L"^aa*"));
+ assertEqualIntA(m, 0, archive_match_include_pattern(m, "^a1*"));
/* Test with 'aa1234', which should not be excluded. */
archive_entry_copy_pathname(ae, "aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aa1234");
failure("'aa1234' should not be excluded");
- assertEqualInt(0, archive_matching_path_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_path_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Test with 'aaa1234', which should be excluded. */
archive_entry_copy_pathname(ae, "aaa1234");
failure("'aaa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_clear(ae);
archive_entry_copy_pathname_w(ae, L"aaa1234");
failure("'aaa1234' should be excluded");
- assertEqualInt(1, archive_matching_path_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_path_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify unmatched_inclusions. */
- assertEqualInt(1, archive_matching_path_unmatched_inclusions(m));
+ assertEqualInt(1, archive_match_path_unmatched_inclusions(m));
/* Verify unmatched inclusion patterns. */
assertEqualIntA(m, ARCHIVE_OK,
- archive_matching_path_unmatched_inclusions_next(m, &mp));
+ archive_match_path_unmatched_inclusions_next(m, &mp));
assertEqualString("^a1*", mp);
assertEqualIntA(m, ARCHIVE_EOF,
- archive_matching_path_unmatched_inclusions_next(m, &mp));
+ archive_match_path_unmatched_inclusions_next(m, &mp));
/* Verify unmatched inclusion patterns again in Wide-Char. */
assertEqualIntA(m, ARCHIVE_OK,
- archive_matching_path_unmatched_inclusions_next_w(m, &wp));
+ archive_match_path_unmatched_inclusions_next_w(m, &wp));
assertEqualWString(L"^a1*", wp);
assertEqualIntA(m, ARCHIVE_EOF,
- archive_matching_path_unmatched_inclusions_next_w(m, &wp));
+ archive_match_path_unmatched_inclusions_next_w(m, &wp));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
-DEFINE_TEST(test_archive_matching_path)
+DEFINE_TEST(test_archive_match_path)
{
test_exclusion_mbs();
test_exclusion_wcs();
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_time(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_NEWER, 7880, 0));
+ assertEqualIntA(m, 0, archive_match_include_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_NEWER, 7880, 0));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, 7880, 0);
archive_entry_set_ctime(ae, 7880, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7879, 999);
archive_entry_set_ctime(ae, 7879, 999);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7881, 0);
archive_entry_set_ctime(ae, 7881, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
archive_entry_set_ctime(ae, 7880, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 0);
archive_entry_set_ctime(ae, 7880, 1);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
time_t now, t;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
time(&now);
- assertEqualIntA(m, 0, archive_matching_include_date(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_NEWER, "1980/2/1 0:0:0 UTC"));
+ assertEqualIntA(m, 0, archive_match_include_date(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_NEWER, "1980/2/1 0:0:0 UTC"));
/* Test1: Allow newer time. */
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 1);
archive_entry_set_ctime(ae, t, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 1);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test2: Allow equal or newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_NEWER | ARCHIVE_MATCHING_EQUAL,
+ assertEqualIntA(m, 0, archive_match_include_date(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_EQUAL,
"1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
time_t now, t;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
time(&now);
- assertEqualIntA(m, 0, archive_matching_include_date_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_NEWER, L"1980/2/1 0:0:0 UTC"));
+ assertEqualIntA(m, 0, archive_match_include_date_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_NEWER, L"1980/2/1 0:0:0 UTC"));
/* Test1: Allow newer time. */
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 1);
archive_entry_set_ctime(ae, t, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 1);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test2: Allow equal or newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_NEWER | ARCHIVE_MATCHING_EQUAL,
+ assertEqualIntA(m, 0, archive_match_include_date_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_EQUAL,
L"1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: newer mtime than a file specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER, "mid_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, "mid_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: newer ctime than a file specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER, "mid_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, "mid_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_copy_pathname(ae, "old_ctime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: newer mtime than a file specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER, L"mid_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, L"mid_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: newer ctime than a file specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER, L"mid_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, L"mid_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
- assertEqualIntA(m, 0, archive_matching_include_time(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_OLDER, 7880, 0));
+ assertEqualIntA(m, 0, archive_match_include_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_OLDER, 7880, 0));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, 7880, 0);
archive_entry_set_ctime(ae, 7880, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7879, 999);
archive_entry_set_ctime(ae, 7879, 999);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7881, 0);
archive_entry_set_ctime(ae, 7881, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
archive_entry_set_ctime(ae, 7879, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7879, 0);
archive_entry_set_ctime(ae, 7880, 1);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
time_t now, t;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
time(&now);
/* Test1: Allow newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_OLDER, "1980/2/1 0:0:0 UTC"));
+ assertEqualIntA(m, 0, archive_match_include_date(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_OLDER, "1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_ctime(ae, t, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_ctime(ae, t, 0);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test2: Allow equal or newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_OLDER | ARCHIVE_MATCHING_EQUAL,
+ assertEqualIntA(m, 0, archive_match_include_date(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_OLDER | ARCHIVE_MATCH_EQUAL,
"1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive *m;
time_t now, t;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
time(&now);
/* Test1: Allow newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_OLDER, L"1980/2/1 0:0:0 UTC"));
+ assertEqualIntA(m, 0, archive_match_include_date_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_OLDER, L"1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_ctime(ae, t, 0);
failure("Its mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_ctime(ae, t, 0);
failure("Its ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Test2: Allow equal or newer time. */
- assertEqualIntA(m, 0, archive_matching_include_date_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_CTIME |
- ARCHIVE_MATCHING_OLDER | ARCHIVE_MATCHING_EQUAL,
+ assertEqualIntA(m, 0, archive_match_include_date_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
+ ARCHIVE_MATCH_OLDER | ARCHIVE_MATCH_EQUAL,
L"1980/2/1 0:0:0 UTC"));
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
archive_entry_set_mtime(ae, t, 0);
archive_entry_set_ctime(ae, t, 0);
failure("Both Its mtime and ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: older mtime than a file specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER, "mid_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, "mid_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: older ctime than a file specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_OLDER, "mid_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, "mid_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: older mtime than a file specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER, L"mid_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, L"mid_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: older ctime than a file specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_OLDER, L"mid_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, L"mid_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: mtime between file specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER, "old_mtime"));
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER, "new_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, "old_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, "new_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: mtime between file specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER, L"old_mtime"));
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER, L"new_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, L"old_mtime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, L"new_mtime"));
/* Verify 'old_mtime' file. */
archive_entry_copy_pathname(ae, "old_mtime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_mtime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'new_mtime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_mtime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: ctime between files specified in MBS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER, "old_ctime"));
- assertEqualIntA(m, 0, archive_matching_include_time_pathname(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_OLDER, "new_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, "old_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, "new_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_copy_pathname(ae, "old_ctime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
if (!assert((a = archive_read_disk_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
archive_entry_free(ae);
return;
}
/*
* Test: ctime between files specified in WCS file name.
*/
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER, L"old_ctime"));
- assertEqualIntA(m, 0, archive_matching_include_time_pathname_w(m,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_OLDER, L"new_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, L"old_ctime"));
+ assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, L"new_ctime"));
/* Verify 'old_ctime' file. */
archive_entry_copy_pathname(ae, "old_ctime");
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("old_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Verify 'mid_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("mid_ctime should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Verify 'new_ctime' file. */
archive_entry_clear(ae);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_entry_from_file(a, ae, -1, NULL));
failure("new_ctime should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/* Clean up. */
archive_read_free(a);
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
static void
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, 7879, 999);
failure("It should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 0);
failure("It should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mtime(ae, 7879, 999);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 0);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_copy_pathname(ae, "file3");
archive_entry_set_mtime(ae, 7879, 999);
failure("It should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 0);
failure("It should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
failure("It should be excluded");
- assertEqualInt(1, archive_matching_time_excluded(m, ae));
- assertEqualInt(1, archive_matching_excluded(m, ae));
+ assertEqualInt(1, archive_match_time_excluded(m, ae));
+ assertEqualInt(1, archive_match_excluded(m, ae));
/*
* "file4" is not registered, that sort of a file should not be
archive_entry_copy_pathname(ae, "file4");
archive_entry_set_mtime(ae, 7879, 999);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 0);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
archive_entry_set_mtime(ae, 7880, 1);
failure("It should not be excluded");
- assertEqualInt(0, archive_matching_time_excluded(m, ae));
- assertEqualInt(0, archive_matching_excluded(m, ae));
+ assertEqualInt(0, archive_match_time_excluded(m, ae));
+ assertEqualInt(0, archive_match_excluded(m, ae));
/* Clean up. */
struct archive_entry *ae;
struct archive *m;
- if (!assert((m = archive_matching_new()) != NULL))
+ if (!assert((m = archive_match_new()) != NULL))
return;
if (!assert((ae = archive_entry_new()) != NULL)) {
- archive_matching_free(m);
+ archive_match_free(m);
return;
}
archive_entry_copy_pathname(ae, "file1");
archive_entry_set_mtime(ae, 7880, 0);
- assertEqualIntA(m, 0, archive_matching_exclude_entry(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER |
- ARCHIVE_MATCHING_EQUAL, ae));
+ assertEqualIntA(m, 0, archive_match_exclude_entry(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
+ ARCHIVE_MATCH_EQUAL, ae));
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mtime(ae, 1, 0);
- assertEqualIntA(m, 0, archive_matching_exclude_entry(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER |
- ARCHIVE_MATCHING_EQUAL, ae));
+ assertEqualIntA(m, 0, archive_match_exclude_entry(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
+ ARCHIVE_MATCH_EQUAL, ae));
archive_entry_copy_pathname(ae, "file3");
archive_entry_set_mtime(ae, 99999, 0);
- assertEqualIntA(m, 0, archive_matching_exclude_entry(m,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER |
- ARCHIVE_MATCHING_EQUAL, ae));
+ assertEqualIntA(m, 0, archive_match_exclude_entry(m,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
+ ARCHIVE_MATCH_EQUAL, ae));
excluded(m);
/* Clean up. */
archive_entry_free(ae);
- archive_matching_free(m);
+ archive_match_free(m);
}
-DEFINE_TEST(test_archive_matching_time)
+DEFINE_TEST(test_archive_match_time)
{
struct stat st;
archive_entry_free(ae);
return;
}
- if (assert((m = archive_matching_new()) != NULL)) {
+ if (assert((m = archive_match_new()) != NULL)) {
archive_entry_free(ae);
archive_read_free(a);
return;
*/
file_count = 3;
assertEqualIntA(m, ARCHIVE_OK,
- archive_matching_exclude_pattern(m, "cb/f2"));
+ archive_match_exclude_pattern(m, "cb/f2"));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_disk_set_matching(a, m, NULL, NULL));
failure("Directory traversals should work as well");
/* Destroy the disk object. */
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
- assertEqualInt(ARCHIVE_OK, archive_matching_free(m));
+ assertEqualInt(ARCHIVE_OK, archive_match_free(m));
archive_entry_free(ae);
}
lr = lafe_line_reader(pathname, 0);
while ((p = lafe_line_reader_next(lr)) != NULL) {
- ret = archive_matching_exclude_pattern(matching, p);
+ ret = archive_match_exclude_pattern(matching, p);
if (ret == ARCHIVE_FATAL)
lafe_errc(1, errno, "Out of memory");
}
lr = lafe_line_reader(pathname, nullSeparator);
while ((p = lafe_line_reader_next(lr)) != NULL) {
- ret = archive_matching_include_pattern(matching, p);
+ ret = archive_match_include_pattern(matching, p);
if (ret == ARCHIVE_FATAL)
lafe_errc(1, errno, "Out of memory");
}
if (getenv(COPYFILE_DISABLE_VAR))
bsdtar->readdisk_flags &= ~ARCHIVE_READDISK_MAC_COPYFILE;
#endif
- bsdtar->matching = archive_matching_new();
+ bsdtar->matching = archive_match_new();
if (bsdtar->matching == NULL)
lafe_errc(1, errno, "Out of memory");
bsdtar->readdisk_flags &= ~ARCHIVE_READDISK_MAC_COPYFILE;
break;
case OPTION_EXCLUDE: /* GNU tar */
- if (archive_matching_exclude_pattern(
+ if (archive_match_exclude_pattern(
bsdtar->matching, bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0,
"Couldn't exclude %s\n", bsdtar->argument);
* no one else needs this to filter entries
* when transforming archives.
*/
- if (archive_matching_include_pattern(bsdtar->matching,
+ if (archive_match_include_pattern(bsdtar->matching,
bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0,
"Failed to add %s to inclusion list",
* TODO: Add corresponding "older" options to reverse these.
*/
case OPTION_NEWER_CTIME: /* GNU tar */
- if (archive_matching_include_date(bsdtar->matching,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER,
+ if (archive_match_include_date(bsdtar->matching,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER,
bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(bsdtar->matching));
break;
case OPTION_NEWER_CTIME_THAN:
- if (archive_matching_include_time_pathname(
- bsdtar->matching,
- ARCHIVE_MATCHING_CTIME | ARCHIVE_MATCHING_NEWER,
+ if (archive_match_include_file_time(bsdtar->matching,
+ ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER,
bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(bsdtar->matching));
break;
case OPTION_NEWER_MTIME: /* GNU tar */
- if (archive_matching_include_date(bsdtar->matching,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER,
+ if (archive_match_include_date(bsdtar->matching,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER,
bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(bsdtar->matching));
break;
case OPTION_NEWER_MTIME_THAN:
- if (archive_matching_include_time_pathname(
- bsdtar->matching,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_NEWER,
+ if (archive_match_include_file_time(bsdtar->matching,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER,
bsdtar->argument) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(bsdtar->matching));
break;
}
- archive_matching_free(bsdtar->matching);
+ archive_match_free(bsdtar->matching);
#if HAVE_REGEX_H
cleanup_substitution(bsdtar);
#endif
int r;
while (*bsdtar->argv) {
- if (archive_matching_include_pattern(bsdtar->matching,
+ if (archive_match_include_pattern(bsdtar->matching,
*bsdtar->argv) != ARCHIVE_OK)
lafe_errc(1, 0, "Error inclusion pattern: %s",
archive_error_string(bsdtar->matching));
for (;;) {
/* Support --fast-read option */
if (bsdtar->option_fast_read &&
- archive_matching_path_unmatched_inclusions(bsdtar->matching) == 0)
+ archive_match_path_unmatched_inclusions(bsdtar->matching) == 0)
break;
r = archive_read_next_header(a, &entry);
* rewrite, there would be no way to exclude foo1/bar
* while allowing foo2/bar.)
*/
- if (archive_matching_excluded(bsdtar->matching, entry))
+ if (archive_match_excluded(bsdtar->matching, entry))
continue; /* Excluded by a pattern test. */
if (mode == 't') {
if (matching == NULL)
return (0);
- while ((r = archive_matching_path_unmatched_inclusions_next(
+ while ((r = archive_match_path_unmatched_inclusions_next(
matching, &p)) == ARCHIVE_OK)
lafe_warnc(0, "%s: %s", p, msg);
if (r == ARCHIVE_FATAL)
lafe_errc(1, errno, "Out of memory");
- return (archive_matching_path_unmatched_inclusions(matching));
+ return (archive_match_path_unmatched_inclusions(matching));
}
lafe_errc(1, 0,
"Cannot append to compressed archive.");
}
- if (archive_matching_exclude_entry(bsdtar->matching,
- ARCHIVE_MATCHING_MTIME | ARCHIVE_MATCHING_OLDER |
- ARCHIVE_MATCHING_EQUAL, entry) != ARCHIVE_OK)
+ if (archive_match_exclude_entry(bsdtar->matching,
+ ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
+ ARCHIVE_MATCH_EQUAL, entry) != ARCHIVE_OK)
lafe_errc(1, 0, "Error : %s",
archive_error_string(bsdtar->matching));
/* Record the last format determination we see */
int e;
while (ARCHIVE_OK == (e = archive_read_next_header(ina, &in_entry))) {
- if (archive_matching_excluded(bsdtar->matching, in_entry))
+ if (archive_match_excluded(bsdtar->matching, in_entry))
continue;
if (bsdtar->option_interactive &&
!yes("copy '%s'", archive_entry_pathname(in_entry)))
projects / thirdparty / libarchive.git / commitdiff
