Back to index

glibc  2.9
Classes | Defines | Functions | Variables
tst-gnuglob.c File Reference
#include <dirent.h>
#include <errno.h>
#include <error.h>
#include <glob.h>
#include <mcheck.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

Go to the source code of this file.

Classes

struct  my_DIR

Defines

#define PRINTF(fmt, args...)
#define nfiles   (sizeof (filesystem) / sizeof (filesystem[0]))
#define nglob_errstring   (sizeof (glob_errstring) / sizeof (glob_errstring[0]))
#define nstrs   (sizeof (strs) / sizeof (strs[0]))
#define test(a, b, c...)

Functions

static long int find_file (const char *s)
static void * my_opendir (const char *s)
static struct direntmy_readdir (void *gdir)
static void my_closedir (void *dir)
static int my_stat (const char *name, struct stat *st)
static const char * flagstr (int flags)
static int test_result (const char *fmt, int flags, glob_t *gl, const char *str[])
int main (void)

Variables

struct {
const char * name
int level
int type
filesystem []
static const char * glob_errstring []

Class Documentation

struct my_DIR

Definition at line 74 of file bug-glob2.c.

Class Members
int idx
int level
char room_for_dirent

Define Documentation

#define nfiles   (sizeof (filesystem) / sizeof (filesystem[0]))

Definition at line 88 of file tst-gnuglob.c.

#define nglob_errstring   (sizeof (glob_errstring) / sizeof (glob_errstring[0]))

Definition at line 280 of file tst-gnuglob.c.

#define nstrs   (sizeof (strs) / sizeof (strs[0]))
#define PRINTF (   fmt,
  args... 
)

Definition at line 37 of file tst-gnuglob.c.

#define test (   a,
  b,
  c... 
)
Value:
fmt = a;                                                             \
  flags = b;                                                         \
  errval = glob (fmt, flags, NULL, &gl);                             \
  if (errval != 0)                                                   \
    {                                                                \
      printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags),       \
             errval >= 0 && errval < nglob_errstring                        \
             ? glob_errstring[errval] : "???");                      \
      result = 1;                                                    \
    }                                                                \
  else                                                               \
    result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL })

Function Documentation

static long int find_file ( const char *  s) [static]

Definition at line 101 of file tst-gnuglob.c.

{
  int level = 1;
  long int idx = 0;

  while (s[0] == '/')
    {
      if (s[1] == '\0')
       {
         s = ".";
         break;
       }
      ++s;
    }

  if (strcmp (s, ".") == 0)
    return 0;

  if (s[0] == '.' && s[1] == '/')
    s += 2;

  while (*s != '\0')
    {
      char *endp = strchrnul (s, '/');

      PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level);

      while (idx < nfiles && filesystem[idx].level >= level)
       {
         if (filesystem[idx].level == level
             && memcmp (s, filesystem[idx].name, endp - s) == 0
             && filesystem[idx].name[endp - s] == '\0')
           break;
         ++idx;
       }

      if (idx == nfiles || filesystem[idx].level < level)
       {
         errno = ENOENT;
         return -1;
       }

      if (*endp == '\0')
       return idx + 1;

      if (filesystem[idx].type != DT_DIR
         && (idx + 1 >= nfiles
             || filesystem[idx].level >= filesystem[idx + 1].level))
       {
         errno = ENOTDIR;
         return -1;
       }

      ++idx;

      s = endp + 1;
      ++level;
    }

  errno = ENOENT;
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* flagstr ( int  flags) [static]

Definition at line 284 of file tst-gnuglob.c.

{
  const char *strs[] =
  {
    "GLOB_ERR", "GLOB_MARK", "GLOB_NOSORT", "GLOB_DOOFSS", "GLOB_NOCHECK",
    "GLOB_APPEND", "GLOB_NOESCAPE", "GLOB_PERIOD", "GLOB_MAGCHAR",
    "GLOB_ALTDIRFUNC", "GLOB_BRACE", "GLOB_NOMAGIC", "GLOB_TILDE",
    "GLOB_ONLYDIR", "GLOB_TILDECHECK"
  };
#define nstrs (sizeof (strs) / sizeof (strs[0]))
  static char buf[100];
  char *cp = buf;
  int cnt;

  for (cnt = 0; cnt < nstrs; ++cnt)
    if (flags & (1 << cnt))
      {
       flags &= ~(1 << cnt);
       if (cp != buf)
         *cp++ = '|';
       cp = stpcpy (cp, strs[cnt]);
      }

  if (flags != 0)
    {
      if (cp != buf)
       *cp++ = '|';
      sprintf (cp, "%#x", flags);
    }

  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( void  )

Definition at line 361 of file tst-gnuglob.c.

{
  glob_t gl;
  int errval;
  int result = 0;
  const char *fmt;
  int flags;

  mtrace ();

  memset (&gl, '\0', sizeof (gl));

  gl.gl_closedir = my_closedir;
  gl.gl_readdir = my_readdir;
  gl.gl_opendir = my_opendir;
  gl.gl_lstat = my_stat;
  gl.gl_stat = my_stat;

#define test(a, b, c...) \
  fmt = a;                                                           \
  flags = b;                                                         \
  errval = glob (fmt, flags, NULL, &gl);                             \
  if (errval != 0)                                                   \
    {                                                                \
      printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags),       \
             errval >= 0 && errval < nglob_errstring                        \
             ? glob_errstring[errval] : "???");                      \
      result = 1;                                                    \
    }                                                                \
  else                                                               \
    result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL })

  test ("*/*/*", GLOB_ALTDIRFUNC,
       "dir1lev1/dir2lev2/dir1lev3",
       "dir1lev1/dir2lev2/file1lev3",
       "dir1lev1/dir2lev2/file2lev3",
       "dir1lev1/dir3lev2/file3lev3",
       "dir1lev1/dir3lev2/file4lev3");

  test ("*/*/*", GLOB_ALTDIRFUNC | GLOB_PERIOD,
       "dir1lev1/dir1lev2/.",
       "dir1lev1/dir1lev2/..",
       "dir1lev1/dir2lev2/.",
       "dir1lev1/dir2lev2/..",
       "dir1lev1/dir2lev2/.foo",
       "dir1lev1/dir2lev2/dir1lev3",
       "dir1lev1/dir2lev2/file1lev3",
       "dir1lev1/dir2lev2/file2lev3",
       "dir1lev1/dir3lev2/.",
       "dir1lev1/dir3lev2/..",
       "dir1lev1/dir3lev2/file3lev3",
       "dir1lev1/dir3lev2/file4lev3",
       "dir2lev1/dir1lev2/.",
       "dir2lev1/dir1lev2/..",
       "dir2lev1/dir1lev2/.dir",
       "dir2lev1/dir1lev2/.foo");

  test ("*/*/.*", GLOB_ALTDIRFUNC,
       "dir1lev1/dir1lev2/.",
       "dir1lev1/dir1lev2/..",
       "dir1lev1/dir2lev2/.",
       "dir1lev1/dir2lev2/..",
       "dir1lev1/dir2lev2/.foo",
       "dir1lev1/dir3lev2/.",
       "dir1lev1/dir3lev2/..",
       "dir2lev1/dir1lev2/.",
       "dir2lev1/dir1lev2/..",
       "dir2lev1/dir1lev2/.dir",
       "dir2lev1/dir1lev2/.foo");

  test ("*1*/*2*/.*", GLOB_ALTDIRFUNC,
       "dir1lev1/dir1lev2/.",
       "dir1lev1/dir1lev2/..",
       "dir1lev1/dir2lev2/.",
       "dir1lev1/dir2lev2/..",
       "dir1lev1/dir2lev2/.foo",
       "dir1lev1/dir3lev2/.",
       "dir1lev1/dir3lev2/..",
       "dir2lev1/dir1lev2/.",
       "dir2lev1/dir1lev2/..",
       "dir2lev1/dir1lev2/.dir",
       "dir2lev1/dir1lev2/.foo");

  test ("*1*/*1*/.*", GLOB_ALTDIRFUNC,
       "dir1lev1/dir1lev2/.",
       "dir1lev1/dir1lev2/..",
       "dir2lev1/dir1lev2/.",
       "dir2lev1/dir1lev2/..",
       "dir2lev1/dir1lev2/.dir",
       "dir2lev1/dir1lev2/.foo");

  test ("\\/*", GLOB_ALTDIRFUNC,
       "/dir1lev1",
       "/dir2lev1",
       "/file1lev1",
       "/file2lev1");

  globfree (&gl);

  return result;
}

Here is the call graph for this function:

static void my_closedir ( void *  dir) [static]

Definition at line 240 of file tst-gnuglob.c.

{
  PRINTF ("my_closedir ()\n");
  free (dir);
}

Here is the caller graph for this function:

static void* my_opendir ( const char *  s) [static]

Definition at line 166 of file tst-gnuglob.c.

{
  long int idx = find_file (s);
  my_DIR *dir;


  if (idx == -1)
    {
      PRINTF ("my_opendir(\"%s\") == NULL\n", s);
      return NULL;
    }

  dir = (my_DIR *) malloc (sizeof (my_DIR));
  if (dir == NULL)
    error (EXIT_FAILURE, errno, "cannot allocate directory handle");

  dir->level = filesystem[idx].level;
  dir->idx = idx;

  PRINTF ("my_opendir(\"%s\") == { level: %d, idx: %ld }\n",
         s, filesystem[idx].level, idx);

  return dir;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct dirent* my_readdir ( void *  gdir) [static, read]

Definition at line 193 of file tst-gnuglob.c.

{
  my_DIR *dir = gdir;

  if (dir->idx == -1)
    {
      PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
             dir->level, (long int) dir->idx);
      return NULL;
    }

  while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level)
    ++dir->idx;

  if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level)
    {
      dir->idx = -1;
      PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
             dir->level, (long int) dir->idx);
      return NULL;
    }

  dir->d.d_ino = dir->idx;

#ifdef _DIRENT_HAVE_D_TYPE
  dir->d.d_type = filesystem[dir->idx].type;
#endif

  strcpy (dir->d.d_name, filesystem[dir->idx].name);

#ifdef _DIRENT_HAVE_D_TYPE
  PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_type: %d, d_name: \"%s\" }\n",
         dir->level, (long int) dir->idx, dir->d.d_ino, dir->d.d_type,
         dir->d.d_name);
#else
  PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_name: \"%s\" }\n",
         dir->level, (long int) dir->idx, dir->d.d_ino,
         dir->d.d_name);
#endif

  ++dir->idx;

  return &dir->d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int my_stat ( const char *  name,
struct stat st 
) [static]

Definition at line 249 of file tst-gnuglob.c.

{
  long int idx = find_file (name);

  if (idx == -1)
    {
      PRINTF ("my_stat (\"%s\", ...) = -1 (%s)\n", name, strerror (errno));
      return -1;
    }

  memset (st, '\0', sizeof (*st));

  if (filesystem[idx].type == DT_UNKNOWN)
    st->st_mode = DTTOIF (idx + 1 < nfiles
                       && filesystem[idx].level < filesystem[idx + 1].level
                       ? DT_DIR : DT_REG) | 0777;
  else
    st->st_mode = DTTOIF (filesystem[idx].type) | 0777;

  PRINTF ("my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int test_result ( const char *  fmt,
int  flags,
glob_t gl,
const char *  str[] 
) [static]

Definition at line 319 of file tst-gnuglob.c.

{
  size_t cnt;
  int result = 0;

  printf ("results for glob (\"%s\", %s)\n", fmt, flagstr (flags));
  for (cnt = 0; cnt < gl->gl_pathc && str[cnt] != NULL; ++cnt)
    {
      int ok = strcmp (gl->gl_pathv[cnt], str[cnt]) == 0;
      const char *errstr = "";

      if (! ok)
       {
         size_t inner;

         for (inner = 0; str[inner] != NULL; ++inner)
           if (strcmp (gl->gl_pathv[cnt], str[inner]) == 0)
             break;

         if (str[inner] == NULL)
           errstr =  ok ? "" : " *** WRONG";
         else
           errstr = ok ? "" : " * wrong position";

         result = 1;
       }

      printf ("  %s%s\n", gl->gl_pathv[cnt], errstr);
    }
  puts ("");

  if (str[cnt] != NULL || cnt < gl->gl_pathc)
    {
      puts ("  *** incorrect number of entries");
      result = 1;
    }

  return result;
}

Here is the call graph for this function:


Variable Documentation

struct { ... } filesystem[] [static]
const char* glob_errstring[] [static]
Initial value:
{
  [GLOB_NOSPACE] = "out of memory",
  [GLOB_ABORTED] = "read error",
  [GLOB_NOMATCH] = "no matches found"
}

Definition at line 274 of file tst-gnuglob.c.