* sysdeps/generic/strcpy_chk.c (__strcpy_chk): Speed up by checking
[glibc.git] / posix / tst-gnuglob.c
blob72f3fa4a3e2e64b25439c6fc0c4d4c82b6840742
1 /* Test the GNU extensions in glob which allow the user to provide callbacks
2 for the filesystem access functions.
3 Copyright (C) 2001-2002 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
5 Contributed by Ulrich Drepper <drepper@redhat.com>, 2001.
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public
18 License along with the GNU C Library; if not, write to the Free
19 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 02111-1307 USA. */
22 #include <dirent.h>
23 #include <errno.h>
24 #include <error.h>
25 #include <glob.h>
26 #include <mcheck.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <sys/stat.h>
33 // #define DEBUG
34 #ifdef DEBUG
35 # define PRINTF(fmt, args...) printf (fmt, ##args)
36 #else
37 # define PRINTF(fmt, args...)
38 #endif
41 static struct
43 const char *name;
44 int level;
45 int type;
46 } filesystem[] =
48 { ".", 1, DT_DIR },
49 { "..", 1, DT_DIR },
50 { "file1lev1", 1, DT_REG },
51 { "file2lev1", 1, DT_UNKNOWN },
52 { "dir1lev1", 1, DT_UNKNOWN },
53 { ".", 2, DT_DIR },
54 { "..", 2, DT_DIR },
55 { "file1lev2", 2, DT_REG },
56 { "dir1lev2", 2, DT_DIR },
57 { ".", 3, DT_DIR },
58 { "..", 3, DT_DIR },
59 { "dir2lev2", 2, DT_DIR },
60 { ".", 3, DT_DIR },
61 { "..", 3, DT_DIR },
62 { ".foo", 3, DT_REG },
63 { "dir1lev3", 3, DT_DIR },
64 { ".", 4, DT_DIR },
65 { "..", 4, DT_DIR },
66 { "file1lev4", 4, DT_REG },
67 { "file1lev3", 3, DT_REG },
68 { "file2lev3", 3, DT_REG },
69 { "file2lev2", 2, DT_REG },
70 { "file3lev2", 2, DT_REG },
71 { "dir3lev2", 2, DT_DIR },
72 { ".", 3, DT_DIR },
73 { "..", 3, DT_DIR },
74 { "file3lev3", 3, DT_REG },
75 { "file4lev3", 3, DT_REG },
76 { "dir2lev1", 1, DT_DIR },
77 { ".", 2, DT_DIR },
78 { "..", 2, DT_DIR },
79 { "dir1lev2", 2, DT_UNKNOWN },
80 { ".", 3, DT_DIR },
81 { "..", 3, DT_DIR },
82 { ".foo", 3, DT_REG },
83 { ".dir", 3, DT_DIR },
84 { ".", 4, DT_DIR },
85 { "..", 4, DT_DIR },
86 { "hidden", 4, DT_REG }
88 #define nfiles (sizeof (filesystem) / sizeof (filesystem[0]))
91 typedef struct
93 int level;
94 int idx;
95 struct dirent d;
96 char room_for_dirent[NAME_MAX];
97 } my_DIR;
100 static long int
101 find_file (const char *s)
103 int level = 1;
104 long int idx = 0;
106 if (strcmp (s, ".") == 0)
107 return 0;
109 if (s[0] == '.' && s[1] == '/')
110 s += 2;
112 while (*s != '\0')
114 char *endp = strchrnul (s, '/');
116 PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level);
118 while (idx < nfiles && filesystem[idx].level >= level)
120 if (filesystem[idx].level == level
121 && memcmp (s, filesystem[idx].name, endp - s) == 0
122 && filesystem[idx].name[endp - s] == '\0')
123 break;
124 ++idx;
127 if (idx == nfiles || filesystem[idx].level < level)
129 errno = ENOENT;
130 return -1;
133 if (*endp == '\0')
134 return idx + 1;
136 if (filesystem[idx].type != DT_DIR
137 && (idx + 1 >= nfiles
138 || filesystem[idx].level >= filesystem[idx + 1].level))
140 errno = ENOTDIR;
141 return -1;
144 ++idx;
146 s = endp + 1;
147 ++level;
150 errno = ENOENT;
151 return -1;
155 static void *
156 my_opendir (const char *s)
158 long int idx = find_file (s);
159 my_DIR *dir;
162 if (idx == -1)
164 PRINTF ("my_opendir(\"%s\") == NULL\n", s);
165 return NULL;
168 dir = (my_DIR *) malloc (sizeof (my_DIR));
169 if (dir == NULL)
170 error (EXIT_FAILURE, errno, "cannot allocate directory handle");
172 dir->level = filesystem[idx].level;
173 dir->idx = idx;
175 PRINTF ("my_opendir(\"%s\") == { level: %d, idx: %ld }\n",
176 s, filesystem[idx].level, idx);
178 return dir;
182 static struct dirent *
183 my_readdir (void *gdir)
185 my_DIR *dir = gdir;
187 if (dir->idx == -1)
189 PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
190 dir->level, (long int) dir->idx);
191 return NULL;
194 while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level)
195 ++dir->idx;
197 if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level)
199 dir->idx = -1;
200 PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
201 dir->level, (long int) dir->idx);
202 return NULL;
205 dir->d.d_ino = dir->idx;
207 #ifdef _DIRENT_HAVE_D_TYPE
208 dir->d.d_type = filesystem[dir->idx].type;
209 #endif
211 strcpy (dir->d.d_name, filesystem[dir->idx].name);
213 #ifdef _DIRENT_HAVE_D_TYPE
214 PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_type: %d, d_name: \"%s\" }\n",
215 dir->level, (long int) dir->idx, dir->d.d_ino, dir->d.d_type,
216 dir->d.d_name);
217 #else
218 PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_name: \"%s\" }\n",
219 dir->level, (long int) dir->idx, dir->d.d_ino,
220 dir->d.d_name);
221 #endif
223 ++dir->idx;
225 return &dir->d;
229 static void
230 my_closedir (void *dir)
232 PRINTF ("my_closedir ()\n");
233 free (dir);
237 /* We use this function for lstat as well since we don't have any. */
238 static int
239 my_stat (const char *name, struct stat *st)
241 long int idx = find_file (name);
243 if (idx == -1)
245 PRINTF ("my_stat (\"%s\", ...) = -1 (%s)\n", name, strerror (errno));
246 return -1;
249 memset (st, '\0', sizeof (*st));
251 if (filesystem[idx].type == DT_UNKNOWN)
252 st->st_mode = DTTOIF (idx + 1 < nfiles
253 && filesystem[idx].level < filesystem[idx + 1].level
254 ? DT_DIR : DT_REG) | 0777;
255 else
256 st->st_mode = DTTOIF (filesystem[idx].type) | 0777;
258 PRINTF ("my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode);
260 return 0;
264 static const char *glob_errstring[] =
266 [GLOB_NOSPACE] = "out of memory",
267 [GLOB_ABORTED] = "read error",
268 [GLOB_NOMATCH] = "no matches found"
270 #define nglob_errstring (sizeof (glob_errstring) / sizeof (glob_errstring[0]))
273 static const char *
274 flagstr (int flags)
276 const char *strs[] =
278 "GLOB_ERR", "GLOB_MARK", "GLOB_NOSORT", "GLOB_DOOFSS", "GLOB_NOCHECK",
279 "GLOB_APPEND", "GLOB_NOESCAPE", "GLOB_PERIOD", "GLOB_MAGCHAR",
280 "GLOB_ALTDIRFUNC", "GLOB_BRACE", "GLOB_NOMAGIC", "GLOB_TILDE",
281 "GLOB_ONLYDIR", "GLOB_TILDECHECK"
283 #define nstrs (sizeof (strs) / sizeof (strs[0]))
284 static char buf[100];
285 char *cp = buf;
286 int cnt;
288 for (cnt = 0; cnt < nstrs; ++cnt)
289 if (flags & (1 << cnt))
291 flags &= ~(1 << cnt);
292 if (cp != buf)
293 *cp++ = '|';
294 cp = stpcpy (cp, strs[cnt]);
297 if (flags != 0)
299 if (cp != buf)
300 *cp++ = '|';
301 sprintf (cp, "%#x", flags);
304 return buf;
308 static int
309 test_result (const char *fmt, int flags, glob_t *gl, const char *str[])
311 size_t cnt;
312 int result = 0;
314 printf ("results for glob (\"%s\", %s)\n", fmt, flagstr (flags));
315 for (cnt = 0; cnt < gl->gl_pathc && str[cnt] != NULL; ++cnt)
317 int ok = strcmp (gl->gl_pathv[cnt], str[cnt]) == 0;
318 const char *errstr = "";
320 if (! ok)
322 size_t inner;
324 for (inner = 0; str[inner] != NULL; ++inner)
325 if (strcmp (gl->gl_pathv[cnt], str[inner]) == 0)
326 break;
328 if (str[inner] == NULL)
329 errstr = ok ? "" : " *** WRONG";
330 else
331 errstr = ok ? "" : " * wrong position";
333 result = 1;
336 printf (" %s%s\n", gl->gl_pathv[cnt], errstr);
338 puts ("");
340 if (str[cnt] != NULL || cnt < gl->gl_pathc)
342 puts (" *** incorrect number of entries");
343 result = 1;
346 return result;
351 main (void)
353 glob_t gl;
354 int errval;
355 int result = 0;
356 const char *fmt;
357 int flags;
359 mtrace ();
361 memset (&gl, '\0', sizeof (gl));
363 gl.gl_closedir = my_closedir;
364 gl.gl_readdir = my_readdir;
365 gl.gl_opendir = my_opendir;
366 gl.gl_lstat = my_stat;
367 gl.gl_stat = my_stat;
369 #define test(a, b, c...) \
370 fmt = a; \
371 flags = b; \
372 errval = glob (fmt, flags, NULL, &gl); \
373 if (errval != 0) \
375 printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags), \
376 errval >= 0 && errval < nglob_errstring \
377 ? glob_errstring[errval] : "???"); \
378 result = 1; \
380 else \
381 result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL })
383 test ("*/*/*", GLOB_ALTDIRFUNC,
384 "dir1lev1/dir2lev2/dir1lev3",
385 "dir1lev1/dir2lev2/file1lev3",
386 "dir1lev1/dir2lev2/file2lev3",
387 "dir1lev1/dir3lev2/file3lev3",
388 "dir1lev1/dir3lev2/file4lev3");
390 test ("*/*/*", GLOB_ALTDIRFUNC | GLOB_PERIOD,
391 "dir1lev1/dir1lev2/.",
392 "dir1lev1/dir1lev2/..",
393 "dir1lev1/dir2lev2/.",
394 "dir1lev1/dir2lev2/..",
395 "dir1lev1/dir2lev2/.foo",
396 "dir1lev1/dir2lev2/dir1lev3",
397 "dir1lev1/dir2lev2/file1lev3",
398 "dir1lev1/dir2lev2/file2lev3",
399 "dir1lev1/dir3lev2/.",
400 "dir1lev1/dir3lev2/..",
401 "dir1lev1/dir3lev2/file3lev3",
402 "dir1lev1/dir3lev2/file4lev3",
403 "dir2lev1/dir1lev2/.",
404 "dir2lev1/dir1lev2/..",
405 "dir2lev1/dir1lev2/.dir",
406 "dir2lev1/dir1lev2/.foo");
408 test ("*/*/.*", GLOB_ALTDIRFUNC,
409 "dir1lev1/dir1lev2/.",
410 "dir1lev1/dir1lev2/..",
411 "dir1lev1/dir2lev2/.",
412 "dir1lev1/dir2lev2/..",
413 "dir1lev1/dir2lev2/.foo",
414 "dir1lev1/dir3lev2/.",
415 "dir1lev1/dir3lev2/..",
416 "dir2lev1/dir1lev2/.",
417 "dir2lev1/dir1lev2/..",
418 "dir2lev1/dir1lev2/.dir",
419 "dir2lev1/dir1lev2/.foo");
421 test ("*1*/*2*/.*", GLOB_ALTDIRFUNC,
422 "dir1lev1/dir1lev2/.",
423 "dir1lev1/dir1lev2/..",
424 "dir1lev1/dir2lev2/.",
425 "dir1lev1/dir2lev2/..",
426 "dir1lev1/dir2lev2/.foo",
427 "dir1lev1/dir3lev2/.",
428 "dir1lev1/dir3lev2/..",
429 "dir2lev1/dir1lev2/.",
430 "dir2lev1/dir1lev2/..",
431 "dir2lev1/dir1lev2/.dir",
432 "dir2lev1/dir1lev2/.foo");
434 test ("*1*/*1*/.*", GLOB_ALTDIRFUNC,
435 "dir1lev1/dir1lev2/.",
436 "dir1lev1/dir1lev2/..",
437 "dir2lev1/dir1lev2/.",
438 "dir2lev1/dir1lev2/..",
439 "dir2lev1/dir1lev2/.dir",
440 "dir2lev1/dir1lev2/.foo");
442 globfree (&gl);
444 return result;