contrib/libarchive/libarchive_fe/matching.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "lafe_platform.h"
  27 __FBSDID("$FreeBSD: src/usr.bin/cpio/matching.c,v 1.2 2008/06/21 02:20:20 kientzle Exp $");
  28
  29 #ifdef HAVE_ERRNO_H
  30 #include <errno.h>
  31 #endif
  32 #ifdef HAVE_STDLIB_H
  33 #include <stdlib.h>
  34 #endif
  35 #ifdef HAVE_STRING_H
  36 #include <string.h>
  37 #endif
  38
  39 #include "err.h"
  40 #include "line_reader.h"
  41 #include "matching.h"
  42 #include "pathmatch.h"
  43
  44 struct match {
  45         struct match     *next;
  46         int               matches;
  47         char              pattern[1];
  48 };
  49
  50 struct lafe_matching {
  51         struct match     *exclusions;
  52         int               exclusions_count;
  53         struct match     *inclusions;
  54         int               inclusions_count;
  55         int               inclusions_unmatched_count;
  56 };
  57
  58 static void     add_pattern(struct match **list, const char *pattern);
  59 static void     initialize_matching(struct lafe_matching **);
  60 static int      match_exclusion(struct match *, const char *pathname);
  61 static int      match_inclusion(struct match *, const char *pathname);
  62
  63 /*
  64  * The matching logic here needs to be re-thought.  I started out to
  65  * try to mimic gtar's matching logic, but it's not entirely
  66  * consistent.  In particular 'tar -t' and 'tar -x' interpret patterns
  67  * on the command line as anchored, but --exclude doesn't.
  68  */
  69
  70 /*
  71  * Utility functions to manage exclusion/inclusion patterns
  72  */
  73
  74 int
  75 lafe_exclude(struct lafe_matching **matching, const char *pattern)
  76 {
  77
  78         if (*matching == NULL)
  79                 initialize_matching(matching);
  80         add_pattern(&((*matching)->exclusions), pattern);
  81         (*matching)->exclusions_count++;
  82         return (0);
  83 }
  84
  85 int
  86 lafe_exclude_from_file(struct lafe_matching **matching, const char *pathname)
  87 {
  88         struct lafe_line_reader *lr;
  89         const char *p;
  90         int ret = 0;
  91
  92         lr = lafe_line_reader(pathname, 0);
  93         while ((p = lafe_line_reader_next(lr)) != NULL) {
  94                 if (lafe_exclude(matching, p) != 0)
  95                         ret = -1;
  96         }
  97         lafe_line_reader_free(lr);
  98         return (ret);
  99 }
 100
 101 int
 102 lafe_include(struct lafe_matching **matching, const char *pattern)
 103 {
 104
 105         if (*matching == NULL)
 106                 initialize_matching(matching);
 107         add_pattern(&((*matching)->inclusions), pattern);
 108         (*matching)->inclusions_count++;
 109         (*matching)->inclusions_unmatched_count++;
 110         return (0);
 111 }
 112
 113 int
 114 lafe_include_from_file(struct lafe_matching **matching, const char *pathname,
 115     int nullSeparator)
 116 {
 117         struct lafe_line_reader *lr;
 118         const char *p;
 119         int ret = 0;
 120
 121         lr = lafe_line_reader(pathname, nullSeparator);
 122         while ((p = lafe_line_reader_next(lr)) != NULL) {
 123                 if (lafe_include(matching, p) != 0)
 124                         ret = -1;
 125         }
 126         lafe_line_reader_free(lr);
 127         return (ret);
 128 }
 129
 130 static void
 131 add_pattern(struct match **list, const char *pattern)
 132 {
 133         struct match *match;
 134         size_t len;
 135
 136         len = strlen(pattern);
 137         match = malloc(sizeof(*match) + len + 1);
 138         if (match == NULL)
 139                 lafe_errc(1, errno, "Out of memory");
 140         strcpy(match->pattern, pattern);
 141         /* Both "foo/" and "foo" should match "foo/bar". */
 142         if (len && match->pattern[len - 1] == '/')
 143                 match->pattern[len - 1] = '\0';
 144         match->next = *list;
 145         *list = match;
 146         match->matches = 0;
 147 }
 148
 149
 150 int
 151 lafe_excluded(struct lafe_matching *matching, const char *pathname)
 152 {
 153         struct match *match;
 154         struct match *matched;
 155
 156         if (matching == NULL)
 157                 return (0);
 158
 159         /* Mark off any unmatched inclusions. */
 160         /* In particular, if a filename does appear in the archive and
 161          * is explicitly included and excluded, then we don't report
 162          * it as missing even though we don't extract it.
 163          */
 164         matched = NULL;
 165         for (match = matching->inclusions; match != NULL; match = match->next){
 166                 if (match->matches == 0
 167                     && match_inclusion(match, pathname)) {
 168                         matching->inclusions_unmatched_count--;
 169                         match->matches++;
 170                         matched = match;
 171                 }
 172         }
 173
 174         /* Exclusions take priority */
 175         for (match = matching->exclusions; match != NULL; match = match->next){
 176                 if (match_exclusion(match, pathname))
 177                         return (1);
 178         }
 179
 180         /* It's not excluded and we found an inclusion above, so it's included. */
 181         if (matched != NULL)
 182                 return (0);
 183
 184
 185         /* We didn't find an unmatched inclusion, check the remaining ones. */
 186         for (match = matching->inclusions; match != NULL; match = match->next){
 187                 /* We looked at previously-unmatched inclusions already. */
 188                 if (match->matches > 0
 189                     && match_inclusion(match, pathname)) {
 190                         match->matches++;
 191                         return (0);
 192                 }
 193         }
 194
 195         /* If there were inclusions, default is to exclude. */
 196         if (matching->inclusions != NULL)
 197             return (1);
 198
 199         /* No explicit inclusions, default is to match. */
 200         return (0);
 201 }
 202
 203 /*
 204  * This is a little odd, but it matches the default behavior of
 205  * gtar.  In particular, 'a*b' will match 'foo/a1111/222b/bar'
 206  *
 207  */
 208 static int
 209 match_exclusion(struct match *match, const char *pathname)
 210 {
 211         return (lafe_pathmatch(match->pattern,
 212                     pathname,
 213                     PATHMATCH_NO_ANCHOR_START | PATHMATCH_NO_ANCHOR_END));
 214 }
 215
 216 /*
 217  * Again, mimic gtar:  inclusions are always anchored (have to match
 218  * the beginning of the path) even though exclusions are not anchored.
 219  */
 220 static int
 221 match_inclusion(struct match *match, const char *pathname)
 222 {
 223         return (lafe_pathmatch(match->pattern, pathname, PATHMATCH_NO_ANCHOR_END));
 224 }
 225
 226 void
 227 lafe_cleanup_exclusions(struct lafe_matching **matching)
 228 {
 229         struct match *p, *q;
 230
 231         if (*matching == NULL)
 232                 return;
 233
 234         for (p = (*matching)->inclusions; p != NULL; ) {
 235                 q = p;
 236                 p = p->next;
 237                 free(q);
 238         }
 239
 240         for (p = (*matching)->exclusions; p != NULL; ) {
 241                 q = p;
 242                 p = p->next;
 243                 free(q);
 244         }
 245
 246         free(*matching);
 247         *matching = NULL;
 248 }
 249
 250 static void
 251 initialize_matching(struct lafe_matching **matching)
 252 {
 253         *matching = calloc(sizeof(**matching), 1);
 254         if (*matching == NULL)
 255                 lafe_errc(1, errno, "No memory");
 256 }
 257
 258 int
 259 lafe_unmatched_inclusions(struct lafe_matching *matching)
 260 {
 261
 262         if (matching == NULL)
 263                 return (0);
 264         return (matching->inclusions_unmatched_count);
 265 }
 266
 267 int
 268 lafe_unmatched_inclusions_warn(struct lafe_matching *matching, const char *msg)
 269 {
 270         struct match *p;
 271
 272         if (matching == NULL)
 273                 return (0);
 274
 275         for (p = matching->inclusions; p != NULL; p = p->next) {
 276                 if (p->matches == 0)
 277                         lafe_warnc(0, "%s: %s", p->pattern, msg);
 278         }
 279
 280         return (matching->inclusions_unmatched_count);
 281 }