src/file_glob.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2013 Index Data
   3  * See the file LICENSE for details.
   4  */
   5
   6 /** \file
   7     \brief File globbing (ala POSIX glob, but simpler)
   8 */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <assert.h>
  19 #include <yaz/wrbuf.h>
  20 #include <yaz/tpath.h>
  21 #include <yaz/log.h>
  22 #include <yaz/dirent.h>
  23 #include <yaz/nmem.h>
  24 #include <yaz/file_glob.h>
  25 #include <yaz/match_glob.h>
  26
  27 struct res_entry {
  28     struct res_entry *next;
  29     char *file;
  30 };
  31
  32 struct glob_res {
  33     NMEM nmem;
  34     size_t number_of_entries;
  35     struct res_entry **last_entry;
  36     struct res_entry *entries;
  37 };
  38
  39 static void glob_r(yaz_glob_res_t res, const char *pattern, size_t off,
  40                    char *prefix)
  41 {
  42     size_t prefix_len = strlen(prefix);
  43     int is_pattern = 0;
  44     size_t i = off;
  45     while (pattern[i] && !strchr("/\\", pattern[i]))
  46     {
  47         if (strchr("?*", pattern[i]))
  48             is_pattern = 1;
  49         i++;
  50     }
  51
  52     if (!is_pattern && pattern[i]) /* no pattern and directory part */
  53     {
  54         i++; /* skip dir sep */
  55         memcpy(prefix + prefix_len, pattern + off, i - off);
  56         prefix[prefix_len + i - off] = '\0';
  57         glob_r(res, pattern, i, prefix);
  58         prefix[prefix_len] = '\0';
  59     }
  60     else
  61     {
  62         DIR * dir = opendir(*prefix ? prefix : "." );
  63
  64         if (dir)
  65         {
  66             struct dirent *ent;
  67
  68             while ((ent = readdir(dir)))
  69             {
  70                 int r;
  71                 memcpy(prefix + prefix_len, pattern + off, i - off);
  72                 prefix[prefix_len + i - off] = '\0';
  73                 r = yaz_match_glob(prefix + prefix_len, ent->d_name);
  74                 prefix[prefix_len] = '\0';
  75
  76                 if (r)
  77                 {
  78                     strcpy(prefix + prefix_len, ent->d_name);
  79                     if (pattern[i])
  80                     {
  81                         glob_r(res, pattern, i, prefix);
  82                     }
  83                     else
  84                     {
  85                         struct res_entry *ent =
  86                             nmem_malloc(res->nmem, sizeof(*ent));
  87                         ent->file = nmem_strdup(res->nmem, prefix);
  88                         ent->next = 0;
  89                         *res->last_entry = ent;
  90                         res->last_entry = &ent->next;
  91                         res->number_of_entries++;
  92                     }
  93                     prefix[prefix_len] = '\0';
  94                 }
  95             }
  96             closedir(dir);
  97         }
  98     }
  99 }
 100
 101 static int cmp_entry(const void *a, const void *b)
 102 {
 103     struct res_entry *ent_a = *(struct res_entry **) a;
 104     struct res_entry *ent_b = *(struct res_entry **) b;
 105     return strcmp(ent_a->file, ent_b->file);
 106 }
 107
 108 static void sort_them(yaz_glob_res_t res)
 109 {
 110     size_t i;
 111     struct res_entry **ent_p;
 112     struct res_entry **ent = nmem_malloc(res->nmem, sizeof(*ent) * res->number_of_entries);
 113     struct res_entry *ent_i = res->entries;
 114     for (i = 0; i < res->number_of_entries; i++)
 115     {
 116         ent[i] = ent_i;
 117         ent_i = ent_i->next;
 118     }
 119     qsort(ent, res->number_of_entries, sizeof(*ent), cmp_entry);
 120     ent_p = &res->entries;
 121     for (i = 0; i < res->number_of_entries; i++)
 122     {
 123         *ent_p = ent[i];
 124         ent_p = &ent[i]->next;
 125     }
 126     *ent_p = 0;
 127 }
 128
 129 int yaz_file_glob(const char *pattern, yaz_glob_res_t *res)
 130 {
 131     char prefix[FILENAME_MAX+1];
 132     NMEM nmem = nmem_create();
 133
 134     *prefix = '\0';
 135     *res = nmem_malloc(nmem, sizeof(**res));
 136     (*res)->number_of_entries = 0;
 137     (*res)->nmem = nmem;
 138     (*res)->entries = 0;
 139     (*res)->last_entry = &(*res)->entries;
 140     glob_r(*res, pattern, 0, prefix);
 141     sort_them(*res);
 142     return 0;
 143 }
 144
 145 void yaz_file_globfree(yaz_glob_res_t *res)
 146 {
 147     if (*res)
 148     {
 149         /* must free entries as well */
 150         nmem_destroy((*res)->nmem);
 151         *res = 0;
 152     }
 153 }
 154
 155 const char *yaz_file_glob_get_file(yaz_glob_res_t res, size_t idx)
 156 {
 157     struct res_entry *ent = res->entries;
 158     while (idx && ent)
 159     {
 160         ent = ent->next;
 161         idx--;
 162     }
 163     if (!ent)
 164         return 0;
 165     return ent->file;
 166 }
 167
 168 size_t yaz_file_glob_get_num(yaz_glob_res_t res)
 169 {
 170     return res->number_of_entries;
 171 }
 172
 173 /*
 174  * Local variables:
 175  * c-basic-offset: 4
 176  * c-file-style: "Stroustrup"
 177  * indent-tabs-mode: nil
 178  * End:
 179  * vim: shiftwidth=4 tabstop=8 expandtab
 180  */
 181