nsz Git - musl/blob - src/regex/glob.c

   1 #include <glob.h>
   2 #include <fnmatch.h>
   3 #include <sys/stat.h>
   4 #include <dirent.h>
   5 #include <limits.h>
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <errno.h>
   9 #include <stddef.h>
  10
  11 struct match
  12 {
  13         struct match *next;
  14         char name[];
  15 };
  16
  17 static int is_literal(const char *p, int useesc)
  18 {
  19         int bracket = 0;
  20         for (; *p; p++) {
  21                 switch (*p) {
  22                 case '\\':
  23                         if (!useesc) break;
  24                 case '?':
  25                 case '*':
  26                         return 0;
  27                 case '[':
  28                         bracket = 1;
  29                         break;
  30                 case ']':
  31                         if (bracket) return 0;
  32                         break;
  33                 }
  34         }
  35         return 1;
  36 }
  37
  38 static int append(struct match **tail, const char *name, size_t len, int mark)
  39 {
  40         struct match *new = malloc(sizeof(struct match) + len + 2);
  41         if (!new) return -1;
  42         (*tail)->next = new;
  43         new->next = NULL;
  44         memcpy(new->name, name, len+1);
  45         if (mark) {
  46                 new->name[len] = '/';
  47                 new->name[len+1] = 0;
  48         }
  49         *tail = new;
  50         return 0;
  51 }
  52
  53 static int match_in_dir(const char *d, const char *p, int flags, int (*errfunc)(const char *path, int err), struct match **tail)
  54 {
  55         DIR *dir;
  56         struct dirent de_buf, *de;
  57         char pat[strlen(p)+1];
  58         char *p2;
  59         size_t l = strlen(d);
  60         int literal;
  61         int fnm_flags= ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
  62                 | ((!(flags & GLOB_PERIOD)) ? FNM_PERIOD : 0);
  63         int error;
  64
  65         if ((p2 = strchr(p, '/'))) {
  66                 strcpy(pat, p);
  67                 pat[p2-p] = 0;
  68                 for (; *p2 == '/'; p2++);
  69                 p = pat;
  70         }
  71         literal = is_literal(p, !(flags & GLOB_NOESCAPE));
  72         if (*d == '/' && !*(d+1)) l = 0;
  73
  74         /* rely on opendir failing for nondirectory objects */
  75         dir = opendir(*d ? d : ".");
  76         error = errno;
  77         if (!dir) {
  78                 /* this is not an error -- we let opendir call stat for us */
  79                 if (error == ENOTDIR) return 0;
  80                 if (error == EACCES && !*p) {
  81                         struct stat st;
  82                         if (!stat(d, &st) && S_ISDIR(st.st_mode)) {
  83                                 if (append(tail, d, l, l))
  84                                         return GLOB_NOSPACE;
  85                                 return 0;
  86                         }
  87                 }
  88                 if (errfunc(d, error) || (flags & GLOB_ERR))
  89                         return GLOB_ABORTED;
  90                 return 0;
  91         }
  92         if (!*p) {
  93                 error = append(tail, d, l, l) ? GLOB_NOSPACE : 0;
  94                 closedir(dir);
  95                 return error;
  96         }
  97         while (!(error = readdir_r(dir, &de_buf, &de)) && de) {
  98                 char namebuf[l+de->d_reclen+2], *name = namebuf;
  99                 if (!literal && fnmatch(p, de->d_name, fnm_flags))
 100                         continue;
 101                 if (literal && strcmp(p, de->d_name))
 102                         continue;
 103                 if (p2 && de->d_type && !S_ISDIR(de->d_type<<12) && !S_ISLNK(de->d_type<<12))
 104                         continue;
 105                 /* With GLOB_PERIOD, don't allow matching . or .. unless
 106                  * fnmatch would match them with FNM_PERIOD rules in effect. */
 107                 if (p2 && (flags & GLOB_PERIOD) && de->d_name[0]=='.'
 108                     && (!de->d_name[1] || de->d_name[1]=='.' && !de->d_name[2])
 109                     && fnmatch(p, de->d_name, fnm_flags | FNM_PERIOD))
 110                         continue;
 111                 if (*d) {
 112                         memcpy(name, d, l);
 113                         name[l] = '/';
 114                         strcpy(name+l+1, de->d_name);
 115                 } else {
 116                         name = de->d_name;
 117                 }
 118                 if (p2) {
 119                         if ((error = match_in_dir(name, p2, flags, errfunc, tail))) {
 120                                 closedir(dir);
 121                                 return error;
 122                         }
 123                 } else {
 124                         int mark = 0;
 125                         if (flags & GLOB_MARK) {
 126                                 if (de->d_type && !S_ISLNK(de->d_type<<12))
 127                                         mark = S_ISDIR(de->d_type<<12);
 128                                 else {
 129                                         struct stat st;
 130                                         stat(name, &st);
 131                                         mark = S_ISDIR(st.st_mode);
 132                                 }
 133                         }
 134                         if (append(tail, name, l+de->d_reclen+1, mark)) {
 135                                 closedir(dir);
 136                                 return GLOB_NOSPACE;
 137                         }
 138                 }
 139         }
 140         closedir(dir);
 141         if (error && (errfunc(d, error) || (flags & GLOB_ERR)))
 142                 return GLOB_ABORTED;
 143         return 0;
 144 }
 145
 146 static int ignore_err(const char *path, int err)
 147 {
 148         return 0;
 149 }
 150
 151 static void freelist(struct match *head)
 152 {
 153         struct match *match, *next;
 154         for (match=head->next; match; match=next) {
 155                 next = match->next;
 156                 free(match);
 157         }
 158 }
 159
 160 static int sort(const void *a, const void *b)
 161 {
 162         return strcmp(*(const char **)a, *(const char **)b);
 163 }
 164
 165 int glob(const char *restrict pat, int flags, int (*errfunc)(const char *path, int err), glob_t *restrict g)
 166 {
 167         const char *p=pat, *d;
 168         struct match head = { .next = NULL }, *tail = &head;
 169         size_t cnt, i;
 170         size_t offs = (flags & GLOB_DOOFFS) ? g->gl_offs : 0;
 171         int error = 0;
 172
 173         if (*p == '/') {
 174                 for (; *p == '/'; p++);
 175                 d = "/";
 176         } else {
 177                 d = "";
 178         }
 179
 180         if (!errfunc) errfunc = ignore_err;
 181
 182         if (!(flags & GLOB_APPEND)) {
 183                 g->gl_offs = offs;
 184                 g->gl_pathc = 0;
 185                 g->gl_pathv = NULL;
 186         }
 187
 188         if (strnlen(p, PATH_MAX+1) > PATH_MAX) return GLOB_NOSPACE;
 189
 190         if (*pat) error = match_in_dir(d, p, flags, errfunc, &tail);
 191         if (error == GLOB_NOSPACE) {
 192                 freelist(&head);
 193                 return error;
 194         }
 195
 196         for (cnt=0, tail=head.next; tail; tail=tail->next, cnt++);
 197         if (!cnt) {
 198                 if (flags & GLOB_NOCHECK) {
 199                         tail = &head;
 200                         if (append(&tail, pat, strlen(pat), 0))
 201                                 return GLOB_NOSPACE;
 202                         cnt++;
 203                 } else
 204                         return GLOB_NOMATCH;
 205         }
 206
 207         if (flags & GLOB_APPEND) {
 208                 char **pathv = realloc(g->gl_pathv, (offs + g->gl_pathc + cnt + 1) * sizeof(char *));
 209                 if (!pathv) {
 210                         freelist(&head);
 211                         return GLOB_NOSPACE;
 212                 }
 213                 g->gl_pathv = pathv;
 214                 offs += g->gl_pathc;
 215         } else {
 216                 g->gl_pathv = malloc((offs + cnt + 1) * sizeof(char *));
 217                 if (!g->gl_pathv) {
 218                         freelist(&head);
 219                         return GLOB_NOSPACE;
 220                 }
 221                 for (i=0; i<offs; i++)
 222                         g->gl_pathv[i] = NULL;
 223         }
 224         for (i=0, tail=head.next; i<cnt; tail=tail->next, i++)
 225                 g->gl_pathv[offs + i] = tail->name;
 226         g->gl_pathv[offs + i] = NULL;
 227         g->gl_pathc += cnt;
 228
 229         if (!(flags & GLOB_NOSORT))
 230                 qsort(g->gl_pathv+offs, cnt, sizeof(char *), sort);
 231
 232         return error;
 233 }
 234
 235 void globfree(glob_t *g)
 236 {
 237         size_t i;
 238         for (i=0; i<g->gl_pathc; i++)
 239                 free(g->gl_pathv[g->gl_offs + i] - offsetof(struct match, name));
 240         free(g->gl_pathv);
 241         g->gl_pathc = 0;
 242         g->gl_pathv = NULL;
 243 }
 244
 245 weak_alias(glob, glob64);
 246 weak_alias(globfree, globfree64);