posix/bug-glob2.c

   1 /* Test glob memory management.
   2    for the filesystem access functions.
   3    Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <errno.h>
  22 #include <error.h>
  23 #include <dirent.h>
  24 #include <glob.h>
  25 #include <mcheck.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <sys/stat.h>
  30
  31 // #define DEBUG
  32 #ifdef DEBUG
  33 # define PRINTF(fmt, args...) \
  34   do                                    \
  35     {                                   \
  36       int save_errno = errno;           \
  37       printf (fmt, ##args);             \
  38       errno = save_errno;               \
  39     } while (0)
  40 #else
  41 # define PRINTF(fmt, args...)
  42 #endif
  43
  44
  45 static struct
  46 {
  47   const char *name;
  48   int level;
  49   int type;
  50   mode_t mode;
  51 } filesystem[] =
  52 {
  53   { ".", 1, DT_DIR, 0755 },
  54   { "..", 1, DT_DIR, 0755 },
  55   { "dir", 1, DT_DIR, 0755 },
  56     { ".", 2, DT_DIR, 0755 },
  57     { "..", 2, DT_DIR, 0755 },
  58     { "readable", 2, DT_DIR, 0755 },
  59       { ".", 3, DT_DIR, 0755 },
  60       { "..", 3, DT_DIR, 0755 },
  61       { "a", 3, DT_REG, 0644 },
  62     { "unreadable", 2, DT_DIR, 0111 },
  63       { ".", 3, DT_DIR, 0111 },
  64       { "..", 3, DT_DIR, 0755 },
  65       { "a", 3, DT_REG, 0644 },
  66     { "zz-readable", 2, DT_DIR, 0755 },
  67       { ".", 3, DT_DIR, 0755 },
  68       { "..", 3, DT_DIR, 0755 },
  69       { "a", 3, DT_REG, 0644 }
  70 };
  71 #define nfiles (sizeof (filesystem) / sizeof (filesystem[0]))
  72
  73
  74 typedef struct
  75 {
  76   int level;
  77   int idx;
  78   struct dirent d;
  79   char room_for_dirent[NAME_MAX];
  80 } my_DIR;
  81
  82
  83 static long int
  84 find_file (const char *s)
  85 {
  86   int level = 1;
  87   long int idx = 0;
  88
  89   if (strcmp (s, ".") == 0)
  90     return 0;
  91
  92   if (s[0] == '.' && s[1] == '/')
  93     s += 2;
  94
  95   while (*s != '\0')
  96     {
  97       char *endp = strchrnul (s, '/');
  98
  99       PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level);
 100
 101       while (idx < nfiles && filesystem[idx].level >= level)
 102         {
 103           if (filesystem[idx].level == level
 104               && memcmp (s, filesystem[idx].name, endp - s) == 0
 105               && filesystem[idx].name[endp - s] == '\0')
 106             break;
 107           ++idx;
 108         }
 109
 110       if (idx == nfiles || filesystem[idx].level < level)
 111         {
 112           errno = ENOENT;
 113           return -1;
 114         }
 115
 116       if (*endp == '\0')
 117         return idx + 1;
 118
 119       if (filesystem[idx].type != DT_DIR
 120           && (idx + 1 >= nfiles
 121               || filesystem[idx].level >= filesystem[idx + 1].level))
 122         {
 123           errno = ENOTDIR;
 124           return -1;
 125         }
 126
 127       ++idx;
 128
 129       s = endp + 1;
 130       ++level;
 131     }
 132
 133   errno = ENOENT;
 134   return -1;
 135 }
 136
 137
 138 static void *
 139 my_opendir (const char *s)
 140 {
 141   long int idx = find_file (s);
 142   my_DIR *dir;
 143
 144   if (idx == -1)
 145     {
 146       PRINTF ("my_opendir(\"%s\") == NULL (%m)\n", s);
 147       return NULL;
 148     }
 149
 150   if ((filesystem[idx].mode & 0400) == 0)
 151     {
 152       errno = EACCES;
 153       PRINTF ("my_opendir(\"%s\") == NULL (%m)\n", s);
 154       return NULL;
 155     }
 156
 157   dir = (my_DIR *) malloc (sizeof (my_DIR));
 158   if (dir == NULL)
 159     {
 160       printf ("cannot allocate directory handle: %m\n");
 161       exit (EXIT_FAILURE);
 162     }
 163
 164   dir->level = filesystem[idx].level;
 165   dir->idx = idx;
 166
 167   PRINTF ("my_opendir(\"%s\") == { level: %d, idx: %ld }\n",
 168           s, filesystem[idx].level, idx);
 169
 170   return dir;
 171 }
 172
 173
 174 static struct dirent *
 175 my_readdir (void *gdir)
 176 {
 177   my_DIR *dir = gdir;
 178
 179   if (dir->idx == -1)
 180     {
 181       PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
 182               dir->level, (long int) dir->idx);
 183       return NULL;
 184     }
 185
 186   while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level)
 187     ++dir->idx;
 188
 189   if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level)
 190     {
 191       dir->idx = -1;
 192       PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
 193               dir->level, (long int) dir->idx);
 194       return NULL;
 195     }
 196
 197   dir->d.d_ino = dir->idx;
 198
 199 #ifdef _DIRENT_HAVE_D_TYPE
 200   dir->d.d_type = filesystem[dir->idx].type;
 201 #endif
 202
 203   strcpy (dir->d.d_name, filesystem[dir->idx].name);
 204
 205 #ifdef _DIRENT_HAVE_D_TYPE
 206   PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_type: %d, d_name: \"%s\" }\n",
 207           dir->level, (long int) dir->idx, dir->d.d_ino, dir->d.d_type,
 208           dir->d.d_name);
 209 #else
 210   PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_name: \"%s\" }\n",
 211           dir->level, (long int) dir->idx, dir->d.d_ino,
 212           dir->d.d_name);
 213 #endif
 214
 215   ++dir->idx;
 216
 217   return &dir->d;
 218 }
 219
 220
 221 static void
 222 my_closedir (void *dir)
 223 {
 224   PRINTF ("my_closedir ()\n");
 225   free (dir);
 226 }
 227
 228
 229 /* We use this function for lstat as well since we don't have any.  */
 230 static int
 231 my_stat (const char *name, struct stat *st)
 232 {
 233   long int idx = find_file (name);
 234
 235   if (idx == -1)
 236     {
 237       PRINTF ("my_stat (\"%s\", ...) = -1 (%m)\n", name);
 238       return -1;
 239     }
 240
 241   memset (st, '\0', sizeof (*st));
 242
 243   if (filesystem[idx].type == DT_UNKNOWN)
 244     st->st_mode = DTTOIF (idx + 1 < nfiles
 245                           && filesystem[idx].level < filesystem[idx + 1].level
 246                           ? DT_DIR : DT_REG) | filesystem[idx].mode;
 247   else
 248     st->st_mode = DTTOIF (filesystem[idx].type) | filesystem[idx].mode;
 249
 250   PRINTF ("my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode);
 251
 252   return 0;
 253 }
 254
 255
 256 static void
 257 init_glob_altdirfuncs (glob_t *pglob)
 258 {
 259   pglob->gl_closedir = my_closedir;
 260   pglob->gl_readdir = my_readdir;
 261   pglob->gl_opendir = my_opendir;
 262   pglob->gl_lstat = my_stat;
 263   pglob->gl_stat = my_stat;
 264 }
 265
 266
 267 int
 268 do_test (void)
 269 {
 270   mtrace ();
 271
 272   glob_t gl;
 273   memset (&gl, 0, sizeof (gl));
 274   init_glob_altdirfuncs (&gl);
 275
 276   if (glob ("dir/*able/*", GLOB_ERR | GLOB_ALTDIRFUNC, NULL, &gl)
 277       != GLOB_ABORTED)
 278     {
 279       puts ("glob did not fail with GLOB_ABORTED");
 280       exit (EXIT_FAILURE);
 281     }
 282
 283   globfree (&gl);
 284
 285   memset (&gl, 0, sizeof (gl));
 286   init_glob_altdirfuncs (&gl);
 287
 288   gl.gl_offs = 3;
 289   if (glob ("dir2/*", GLOB_DOOFFS, NULL, &gl) != GLOB_NOMATCH)
 290     {
 291       puts ("glob did not fail with GLOB_NOMATCH");
 292       exit (EXIT_FAILURE);
 293     }
 294
 295   globfree (&gl);
 296
 297   muntrace ();
 298
 299   return 0;
 300 }
 301
 302 #define TEST_FUNCTION do_test ()
 303 #include "../test-skeleton.c"