about summary refs log tree commit diff
path: root/dirent/scandirat.c
blob: d7ae5e52c8517e19b3de95e96c308d6d5c671df8 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/* Copyright (C) 1992-2015 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   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/>.  */

/* We need to avoid the header declaration of scandir64, because
   the types don't match scandir and then the compiler will
   complain about the mismatch when we do the alias below.  */
#define scandirat64       __renamed_scandirat64

#include <dirent.h>

#undef  scandirat64

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <bits/libc-lock.h>

#ifndef SCANDIRAT
# define SCANDIRAT __scandirat
# define READDIR __readdir
# define DIRENT_TYPE struct dirent
# define SCANDIRAT_WEAK_ALIAS
#endif


int
SCANDIRAT (dfd, dir, namelist, select, cmp)
     int dfd;
     const char *dir;
     DIRENT_TYPE ***namelist;
     int (*select) (const DIRENT_TYPE *);
     int (*cmp) (const DIRENT_TYPE **, const DIRENT_TYPE **);
{
  DIR *dp = __opendirat (dfd, dir);
  DIRENT_TYPE **v = NULL;
  size_t vsize = 0;
  struct scandir_cancel_struct c;
  DIRENT_TYPE *d;
  int save;

  if (dp == NULL)
    return -1;

  save = errno;
  __set_errno (0);

  c.dp = dp;
  c.v = NULL;
  c.cnt = 0;
  __libc_cleanup_push (__scandir_cancel_handler, &c);

  while ((d = READDIR (dp)) != NULL)
    {
      int use_it = select == NULL;

      if (! use_it)
	{
	  use_it = select (d);
	  /* The select function might have changed errno.  It was
	     zero before and it need to be again to make the latter
	     tests work.  */
	  __set_errno (0);
	}

      if (use_it)
	{
	  DIRENT_TYPE *vnew;
	  size_t dsize;

	  /* Ignore errors from select or readdir */
	  __set_errno (0);

	  if (__glibc_unlikely (c.cnt == vsize))
	    {
	      DIRENT_TYPE **new;
	      if (vsize == 0)
		vsize = 10;
	      else
		vsize *= 2;
	      new = (DIRENT_TYPE **) realloc (v, vsize * sizeof (*v));
	      if (new == NULL)
		break;
	      v = new;
	      c.v = (void *) v;
	    }

	  dsize = &d->d_name[_D_ALLOC_NAMLEN (d)] - (char *) d;
	  vnew = (DIRENT_TYPE *) malloc (dsize);
	  if (vnew == NULL)
	    break;

	  v[c.cnt++] = (DIRENT_TYPE *) memcpy (vnew, d, dsize);
	}
    }

  if (__builtin_expect (errno, 0) != 0)
    {
      save = errno;

      while (c.cnt > 0)
	free (v[--c.cnt]);
      free (v);
      c.cnt = -1;
    }
  else
    {
      /* Sort the list if we have a comparison function to sort with.  */
      if (cmp != NULL)
	qsort (v, c.cnt, sizeof (*v),
	       (int (*) (const void *, const void *)) cmp);

      *namelist = v;
    }

  __libc_cleanup_pop (0);

  (void) __closedir (dp);
  __set_errno (save);

  return c.cnt;
}
libc_hidden_def (SCANDIRAT)
#ifdef SCANDIRAT_WEAK_ALIAS
weak_alias (__scandirat, scandirat)
#endif

#ifdef _DIRENT_MATCHES_DIRENT64
weak_alias (scandirat, scandirat64)
#endif