1/* Copyright (C) 1993-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
17
18#include <alloca.h>
19#include <assert.h>
20#include <errno.h>
21#include <dirent.h>
22#include <stddef.h>
23#include <stdint.h>
24#include <string.h>
25#include <unistd.h>
26#include <sys/param.h>
27#include <sys/types.h>
28
29#include <sysdep.h>
30#include <sys/syscall.h>
31
32#include <linux/posix_types.h>
33
34#include <kernel-features.h>
35
36/* For Linux we need a special version of this file since the
37 definition of `struct dirent' is not the same for the kernel and
38 the libc. There is one additional field which might be introduced
39 in the kernel structure in the future.
40
41 Here is the kernel definition of `struct dirent' as of 2.1.20: */
42
43struct kernel_dirent
44 {
45 long int d_ino;
46 __kernel_off_t d_off;
47 unsigned short int d_reclen;
48 char d_name[256];
49 };
50
51struct kernel_dirent64
52 {
53 uint64_t d_ino;
54 int64_t d_off;
55 unsigned short int d_reclen;
56 unsigned char d_type;
57 char d_name[256];
58 };
59
60#ifndef __GETDENTS
61# define __GETDENTS __getdents
62#endif
63#ifndef DIRENT_TYPE
64# define DIRENT_TYPE struct dirent
65#endif
66#ifndef DIRENT_SET_DP_INO
67# define DIRENT_SET_DP_INO(dp, value) (dp)->d_ino = (value)
68#endif
69
70/* The problem here is that we cannot simply read the next NBYTES
71 bytes. We need to take the additional field into account. We use
72 some heuristic. Assuming the directory contains names with 14
73 characters on average we can compute an estimated number of entries
74 which fit in the buffer. Taking this number allows us to specify a
75 reasonable number of bytes to read. If we should be wrong, we can
76 reset the file descriptor. In practice the kernel is limiting the
77 amount of data returned much more then the reduced buffer size. */
78ssize_t
79internal_function
80__GETDENTS (int fd, char *buf, size_t nbytes)
81{
82 ssize_t retval;
83
84 /* The d_ino and d_off fields in kernel_dirent and dirent must have
85 the same sizes and alignments. */
86 if (sizeof (DIRENT_TYPE) == sizeof (struct dirent)
87 && (sizeof (((struct kernel_dirent *) 0)->d_ino)
88 == sizeof (((struct dirent *) 0)->d_ino))
89 && (sizeof (((struct kernel_dirent *) 0)->d_off)
90 == sizeof (((struct dirent *) 0)->d_off))
91 && (offsetof (struct kernel_dirent, d_off)
92 == offsetof (struct dirent, d_off))
93 && (offsetof (struct kernel_dirent, d_reclen)
94 == offsetof (struct dirent, d_reclen)))
95 {
96 retval = INLINE_SYSCALL (getdents, 3, fd, buf, nbytes);
97
98 /* The kernel added the d_type value after the name. Change
99 this now. */
100 if (retval != -1)
101 {
102 union
103 {
104 struct kernel_dirent k;
105 struct dirent u;
106 } *kbuf = (void *) buf;
107
108 while ((char *) kbuf < buf + retval)
109 {
110 char d_type = *((char *) kbuf + kbuf->k.d_reclen - 1);
111 memmove (kbuf->u.d_name, kbuf->k.d_name,
112 strlen (kbuf->k.d_name) + 1);
113 kbuf->u.d_type = d_type;
114
115 kbuf = (void *) ((char *) kbuf + kbuf->k.d_reclen);
116 }
117 }
118
119 return retval;
120 }
121
122 off64_t last_offset = -1;
123
124#ifdef __NR_getdents64
125 {
126 union
127 {
128 struct kernel_dirent64 k;
129 DIRENT_TYPE u;
130 char b[1];
131 } *kbuf = (void *) buf, *outp, *inp;
132 size_t kbytes = nbytes;
133 if (offsetof (DIRENT_TYPE, d_name)
134 < offsetof (struct kernel_dirent64, d_name)
135 && nbytes <= sizeof (DIRENT_TYPE))
136 {
137 kbytes = (nbytes + offsetof (struct kernel_dirent64, d_name)
138 - offsetof (DIRENT_TYPE, d_name));
139 kbuf = __alloca(kbytes);
140 }
141 retval = INLINE_SYSCALL (getdents64, 3, fd, kbuf, kbytes);
142 const size_t size_diff = (offsetof (struct kernel_dirent64, d_name)
143 - offsetof (DIRENT_TYPE, d_name));
144
145 /* Return the error if encountered. */
146 if (retval == -1)
147 return -1;
148
149 /* If the structure returned by the kernel is identical to what we
150 need, don't do any conversions. */
151 if (offsetof (DIRENT_TYPE, d_name)
152 == offsetof (struct kernel_dirent64, d_name)
153 && sizeof (outp->u.d_ino) == sizeof (inp->k.d_ino)
154 && sizeof (outp->u.d_off) == sizeof (inp->k.d_off))
155 return retval;
156
157 /* These two pointers might alias the same memory buffer.
158 Standard C requires that we always use the same type for them,
159 so we must use the union type. */
160 inp = kbuf;
161 outp = (void *) buf;
162
163 while (&inp->b < &kbuf->b + retval)
164 {
165 const size_t alignment = __alignof__ (DIRENT_TYPE);
166 /* Since inp->k.d_reclen is already aligned for the kernel
167 structure this may compute a value that is bigger
168 than necessary. */
169 size_t old_reclen = inp->k.d_reclen;
170 size_t new_reclen = ((old_reclen - size_diff + alignment - 1)
171 & ~(alignment - 1));
172
173 /* Copy the data out of the old structure into temporary space.
174 Then copy the name, which may overlap if BUF == KBUF. */
175 const uint64_t d_ino = inp->k.d_ino;
176 const int64_t d_off = inp->k.d_off;
177 const uint8_t d_type = inp->k.d_type;
178
179 memmove (outp->u.d_name, inp->k.d_name,
180 old_reclen - offsetof (struct kernel_dirent64, d_name));
181
182 /* Now we have copied the data from INP and access only OUTP. */
183
184 DIRENT_SET_DP_INO (&outp->u, d_ino);
185 outp->u.d_off = d_off;
186 if ((sizeof (outp->u.d_ino) != sizeof (inp->k.d_ino)
187 && outp->u.d_ino != d_ino)
188 || (sizeof (outp->u.d_off) != sizeof (inp->k.d_off)
189 && outp->u.d_off != d_off))
190 {
191 /* Overflow. If there was at least one entry
192 before this one, return them without error,
193 otherwise signal overflow. */
194 if (last_offset != -1)
195 {
196 __lseek64 (fd, last_offset, SEEK_SET);
197 return outp->b - buf;
198 }
199 __set_errno (EOVERFLOW);
200 return -1;
201 }
202
203 last_offset = d_off;
204 outp->u.d_reclen = new_reclen;
205 outp->u.d_type = d_type;
206
207 inp = (void *) inp + old_reclen;
208 outp = (void *) outp + new_reclen;
209 }
210
211 return outp->b - buf;
212 }
213#endif
214 {
215 size_t red_nbytes;
216 struct kernel_dirent *skdp, *kdp;
217 const size_t size_diff = (offsetof (DIRENT_TYPE, d_name)
218 - offsetof (struct kernel_dirent, d_name));
219
220 red_nbytes = MIN (nbytes
221 - ((nbytes / (offsetof (DIRENT_TYPE, d_name) + 14))
222 * size_diff),
223 nbytes - size_diff);
224
225 skdp = kdp = __alloca (red_nbytes);
226
227 retval = INLINE_SYSCALL (getdents, 3, fd, (char *) kdp, red_nbytes);
228
229 if (retval == -1)
230 return -1;
231
232 DIRENT_TYPE *dp = (DIRENT_TYPE *) buf;
233 while ((char *) kdp < (char *) skdp + retval)
234 {
235 const size_t alignment = __alignof__ (DIRENT_TYPE);
236 /* Since kdp->d_reclen is already aligned for the kernel structure
237 this may compute a value that is bigger than necessary. */
238 size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1)
239 & ~(alignment - 1));
240 if ((char *) dp + new_reclen > buf + nbytes)
241 {
242 /* Our heuristic failed. We read too many entries. Reset
243 the stream. */
244 assert (last_offset != -1);
245 __lseek64 (fd, last_offset, SEEK_SET);
246
247 if ((char *) dp == buf)
248 {
249 /* The buffer the user passed in is too small to hold even
250 one entry. */
251 __set_errno (EINVAL);
252 return -1;
253 }
254
255 break;
256 }
257
258 last_offset = kdp->d_off;
259 DIRENT_SET_DP_INO(dp, kdp->d_ino);
260 dp->d_off = kdp->d_off;
261 dp->d_reclen = new_reclen;
262 dp->d_type = *((char *) kdp + kdp->d_reclen - 1);
263 memcpy (dp->d_name, kdp->d_name,
264 kdp->d_reclen - offsetof (struct kernel_dirent, d_name));
265
266 dp = (DIRENT_TYPE *) ((char *) dp + new_reclen);
267 kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen);
268 }
269
270 return (char *) dp - buf;
271 }
272}
273