text: /* Test the GNU extensions in glob which allow the user to provide callbacks
     for the filesystem access functions.
     Copyright (C) 2001-2016 Free Software Foundation, Inc.
     This file is part of the GNU C Library.
     Contributed by Ulrich Drepper <drepper@redhat.com>, 2001.
  
     The GNU C Library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
  
     The GNU C Library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
  
     You should have received a copy of the GNU Lesser General Public
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
  #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>
  
  
  // #define DEBUG
  #ifdef DEBUG
  # define PRINTF(fmt, args...) printf (fmt, ##args)
  #else
  # define PRINTF(fmt, args...)
  #endif
  
  
  static struct
  {
    const char *name;
    int level;
    int type;
  } filesystem[] =
  {
    { ".", 1, DT_DIR },
    { "..", 1, DT_DIR },
    { "file1lev1", 1, DT_REG },
    { "file2lev1", 1, DT_UNKNOWN },
    { "dir1lev1", 1, DT_UNKNOWN },
      { ".", 2, DT_DIR },
      { "..", 2, DT_DIR },
      { "file1lev2", 2, DT_REG },
      { "dir1lev2", 2, DT_DIR },
        { ".", 3, DT_DIR },
        { "..", 3, DT_DIR },
      { "dir2lev2", 2, DT_DIR },
        { ".", 3, DT_DIR },
        { "..", 3, DT_DIR },
        { ".foo", 3, DT_REG },
        { "dir1lev3", 3, DT_DIR },
  	{ ".", 4, DT_DIR },
  	{ "..", 4, DT_DIR },
  	{ "file1lev4", 4, DT_REG },
        { "file1lev3", 3, DT_REG },
        { "file2lev3", 3, DT_REG },
      { "file2lev2", 2, DT_REG },
      { "file3lev2", 2, DT_REG },
      { "dir3lev2", 2, DT_DIR },
        { ".", 3, DT_DIR },
        { "..", 3, DT_DIR },
        { "file3lev3", 3, DT_REG },
        { "file4lev3", 3, DT_REG },
    { "dir2lev1", 1, DT_DIR },
      { ".", 2, DT_DIR },
      { "..", 2, DT_DIR },
      { "dir1lev2", 2, DT_UNKNOWN },
        { ".", 3, DT_DIR },
        { "..", 3, DT_DIR },
        { ".foo", 3, DT_REG },
        { ".dir", 3, DT_DIR },
  	{ ".", 4, DT_DIR },
  	{ "..", 4, DT_DIR },
  	{ "hidden", 4, DT_REG }
  };
  #define nfiles (sizeof (filesystem) / sizeof (filesystem[0]))
  
  
  typedef struct
  {
    int level;
    int idx;
    struct dirent d;
    char room_for_dirent[NAME_MAX];
  } my_DIR;
  
  
  static long int
  find_file (const char *s)
  {
    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;
  }
  
  
  static void *
  my_opendir (const char *s)
  {
    long int idx = find_file (s);
    my_DIR *dir;
  
  
    if (idx == -1 || filesystem[idx].type != DT_DIR)
      {
        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;
  }
  
  
  static struct dirent *
  my_readdir (void *gdir)
  {
    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 = 1;		/* glob should not skip this entry.  */
  
  #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;
  }
  
  
  static void
  my_closedir (void *dir)
  {
    PRINTF ("my_closedir ()\n");
    free (dir);
  }
  
  
  /* We use this function for lstat as well since we don't have any.  */
  static int
  my_stat (const char *name, struct stat *st)
  {
    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;
  }
  
  
  static const char *glob_errstring[] =
  {
    [GLOB_NOSPACE] = "out of memory",
    [GLOB_ABORTED] = "read error",
    [GLOB_NOMATCH] = "no matches found"
  };
  #define nglob_errstring (sizeof (glob_errstring) / sizeof (glob_errstring[0]))
  
  
  static const char *
  flagstr (int flags)
  {
    static const char *const 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;
  #undef nstrs
  }
  
  
  static const char *
  errstr (int val)
  {
    static const char *const strs[] =
      {
        [GLOB_NOSPACE] = "GLOB_NOSPACE",
        [GLOB_ABORTED] = "GLOB_ABORTED",
        [GLOB_NOMATCH] = "GLOB_NOMATCH",
        [GLOB_NOSYS] = "GLOB_NOSYS"
      };
  #define nstrs (sizeof (strs) / sizeof (strs[0]))
    static char buf[100];
    if (val < 0 || val >= nstrs || strs[val] == NULL)
      {
        snprintf (buf, sizeof (buf), "GLOB_??? (%d)", val);
        return buf;
      }
    return strs[val];
  #undef nstrs
  }
  
  
  static int
  test_result (const char *fmt, int flags, glob_t *gl, const char *str[])
  {
    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;
  }
  
  
  static int
  do_test (void)
  {
    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, r, c...) \
    fmt = a;								      \
    flags = GLOB_ALTDIRFUNC | b;						      \
    errval = glob (fmt, flags, NULL, &gl);				      \
    if (errval != r)							      \
      {									      \
        if (r == 0)							      \
  	printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags),	      \
  		errval >= 0 && errval < nglob_errstring			      \
  		? glob_errstring[errval] : "???");			      \
        else								      \
  	printf ("glob (\"%s\", %s) did not fail\n", fmt, flagstr (flags));    \
        result = 1;							      \
      }									      \
    else if (r == 0)							      \
      result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL });    \
    else									      \
      printf ("result for glob (\"%s\", %s) = %s\n\n", fmt, flagstr (flags),    \
  	    errstr (errval))
  
    test ("*/*/*", 0, 0,
  	"dir1lev1/dir2lev2/dir1lev3",
  	"dir1lev1/dir2lev2/file1lev3",
  	"dir1lev1/dir2lev2/file2lev3",
  	"dir1lev1/dir3lev2/file3lev3",
  	"dir1lev1/dir3lev2/file4lev3");
  
    test ("*/*/*", GLOB_PERIOD, 0,
  	"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 ("*/*/.*", 0, 0,
  	"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*/.*", 0, 0,
  	"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*/.*", 0, 0,
  	"dir1lev1/dir1lev2/.",
  	"dir1lev1/dir1lev2/..",
  	"dir2lev1/dir1lev2/.",
  	"dir2lev1/dir1lev2/..",
  	"dir2lev1/dir1lev2/.dir",
  	"dir2lev1/dir1lev2/.foo");
  
    test ("\\/*", 0, 0,
  	"/dir1lev1",
  	"/dir2lev1",
  	"/file1lev1",
  	"/file2lev1");
  
    test ("*/*/", 0 , 0,
  	"dir1lev1/dir1lev2/",
  	"dir1lev1/dir2lev2/",
  	"dir1lev1/dir3lev2/",
  	"dir2lev1/dir1lev2/");
  
    test ("", 0, GLOB_NOMATCH, NULL);
  
    test ("", GLOB_NOCHECK, 0, "");
  
    globfree (&gl);
  
    return result;
  }
  
  #define TEST_FUNCTION do_test ()
  #include "../test-skeleton.c"
  