[thirdparty/glibc.git] / dirent / dirent.h

/* Copyright (C) 1991-2019 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
   <https://www.gnu.org/licenses/>.  */

/*
 *	POSIX Standard: 5.1.2 Directory Operations	<dirent.h>
 */

#ifndef	_DIRENT_H
#define	_DIRENT_H	1

#include <features.h>

__BEGIN_DECLS

#include <bits/types.h>

#ifdef __USE_XOPEN
# ifndef __ino_t_defined
#  ifndef __USE_FILE_OFFSET64
typedef __ino_t ino_t;
#  else
typedef __ino64_t ino_t;
#  endif
#  define __ino_t_defined
# endif
# if defined __USE_LARGEFILE64 && !defined __ino64_t_defined
typedef __ino64_t ino64_t;
#  define __ino64_t_defined
# endif
#endif

/* This file defines `struct dirent'.

   It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen'
   member that gives the length of `d_name'.

   It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen'
   member that gives the size of the entire directory entry.

   It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off'
   member that gives the file offset of the next directory entry.

   It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type'
   member that gives the type of the file.
 */

#include <bits/dirent.h>

#if defined __USE_MISC && !defined d_fileno
# define d_ino	d_fileno		 /* Backward compatibility.  */
#endif

/* These macros extract size information from a `struct dirent *'.
   They may evaluate their argument multiple times, so it must not
   have side effects.  Each of these may involve a relatively costly
   call to `strlen' on some systems, so these values should be cached.

   _D_EXACT_NAMLEN (DP)	returns the length of DP->d_name, not including
   its terminating null character.

   _D_ALLOC_NAMLEN (DP)	returns a size at least (_D_EXACT_NAMLEN (DP) + 1);
   that is, the allocation size needed to hold the DP->d_name string.
   Use this macro when you don't need the exact length, just an upper bound.
   This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN.
   */

#ifdef _DIRENT_HAVE_D_NAMLEN
# define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
# define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
#else
# define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name))
# ifdef _DIRENT_HAVE_D_RECLEN
#  define _D_ALLOC_NAMLEN(d) (((char *) (d) + (d)->d_reclen) - &(d)->d_name[0])
# else
#  define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name \
			      : _D_EXACT_NAMLEN (d) + 1)
# endif
#endif


#ifdef __USE_MISC
/* File types for `d_type'.  */
enum
  {
    DT_UNKNOWN = 0,
# define DT_UNKNOWN	DT_UNKNOWN
    DT_FIFO = 1,
# define DT_FIFO	DT_FIFO
    DT_CHR = 2,
# define DT_CHR		DT_CHR
    DT_DIR = 4,
# define DT_DIR		DT_DIR
    DT_BLK = 6,
# define DT_BLK		DT_BLK
    DT_REG = 8,
# define DT_REG		DT_REG
    DT_LNK = 10,
# define DT_LNK		DT_LNK
    DT_SOCK = 12,
# define DT_SOCK	DT_SOCK
    DT_WHT = 14
# define DT_WHT		DT_WHT
  };

/* Convert between stat structure types and directory types.  */
# define IFTODT(mode)	(((mode) & 0170000) >> 12)
# define DTTOIF(dirtype)	((dirtype) << 12)
#endif


/* This is the data type of directory stream objects.
   The actual structure is opaque to users.  */
typedef struct __dirstream DIR;

/* Open a directory stream on NAME.
   Return a DIR stream on the directory, or NULL if it could not be opened.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern DIR *opendir (const char *__name) __nonnull ((1));

#ifdef __USE_XOPEN2K8
/* Same as opendir, but open the stream on the file descriptor FD.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern DIR *fdopendir (int __fd);
#endif

/* Close the directory stream DIRP.
   Return 0 if successful, -1 if not.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int closedir (DIR *__dirp) __nonnull ((1));

/* Read a directory entry from DIRP.  Return a pointer to a `struct
   dirent' describing the entry, or NULL for EOF or error.  The
   storage returned may be overwritten by a later readdir call on the
   same DIR stream.

   If the Large File Support API is selected we have to use the
   appropriate interface.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
#ifndef __USE_FILE_OFFSET64
extern struct dirent *readdir (DIR *__dirp) __nonnull ((1));
#else
# ifdef __REDIRECT
extern struct dirent *__REDIRECT (readdir, (DIR *__dirp), readdir64)
     __nonnull ((1));
# else
#  define readdir readdir64
# endif
#endif

#ifdef __USE_LARGEFILE64
extern struct dirent64 *readdir64 (DIR *__dirp) __nonnull ((1));
#endif

#ifdef __USE_POSIX
/* Reentrant version of `readdir'.  Return in RESULT a pointer to the
   next entry.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
# ifndef __USE_FILE_OFFSET64
extern int readdir_r (DIR *__restrict __dirp,
		      struct dirent *__restrict __entry,
		      struct dirent **__restrict __result)
     __nonnull ((1, 2, 3)) __attribute_deprecated__;
# else
#  ifdef __REDIRECT
extern int __REDIRECT (readdir_r,
		       (DIR *__restrict __dirp,
			struct dirent *__restrict __entry,
			struct dirent **__restrict __result),
		       readdir64_r)
  __nonnull ((1, 2, 3)) __attribute_deprecated__;
#  else
#   define readdir_r readdir64_r
#  endif
# endif

# ifdef __USE_LARGEFILE64
extern int readdir64_r (DIR *__restrict __dirp,
			struct dirent64 *__restrict __entry,
			struct dirent64 **__restrict __result)
  __nonnull ((1, 2, 3)) __attribute_deprecated__;
# endif
#endif	/* POSIX or misc */

/* Rewind DIRP to the beginning of the directory.  */
extern void rewinddir (DIR *__dirp) __THROW __nonnull ((1));

#if defined __USE_MISC || defined __USE_XOPEN
# include <bits/types.h>

/* Seek to position POS on DIRP.  */
extern void seekdir (DIR *__dirp, long int __pos) __THROW __nonnull ((1));

/* Return the current position of DIRP.  */
extern long int telldir (DIR *__dirp) __THROW __nonnull ((1));
#endif

#ifdef __USE_XOPEN2K8

/* Return the file descriptor used by DIRP.  */
extern int dirfd (DIR *__dirp) __THROW __nonnull ((1));

# if defined __OPTIMIZE__ && defined _DIR_dirfd
#  define dirfd(dirp)	_DIR_dirfd (dirp)
# endif

# ifdef __USE_MISC
#  ifndef MAXNAMLEN
/* Get the definitions of the POSIX.1 limits.  */
#  include <bits/posix1_lim.h>

/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'.  */
#   ifdef NAME_MAX
#    define MAXNAMLEN	NAME_MAX
#   else
#    define MAXNAMLEN	255
#   endif
#  endif
# endif

# define __need_size_t
# include <stddef.h>

/* Scan the directory DIR, calling SELECTOR on each directory entry.
   Entries for which SELECT returns nonzero are individually malloc'd,
   sorted using qsort with CMP, and collected in a malloc'd array in
   *NAMELIST.  Returns the number of entries selected, or -1 on error.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
# ifndef __USE_FILE_OFFSET64
extern int scandir (const char *__restrict __dir,
		    struct dirent ***__restrict __namelist,
		    int (*__selector) (const struct dirent *),
		    int (*__cmp) (const struct dirent **,
				  const struct dirent **))
     __nonnull ((1, 2));
# else
#  ifdef __REDIRECT
extern int __REDIRECT (scandir,
		       (const char *__restrict __dir,
			struct dirent ***__restrict __namelist,
			int (*__selector) (const struct dirent *),
			int (*__cmp) (const struct dirent **,
				      const struct dirent **)),
		       scandir64) __nonnull ((1, 2));
#  else
#   define scandir scandir64
#  endif
# endif

# if defined __USE_GNU && defined __USE_LARGEFILE64
/* This function is like `scandir' but it uses the 64bit dirent structure.
   Please note that the CMP function must now work with struct dirent64 **.  */
extern int scandir64 (const char *__restrict __dir,
		      struct dirent64 ***__restrict __namelist,
		      int (*__selector) (const struct dirent64 *),
		      int (*__cmp) (const struct dirent64 **,
				    const struct dirent64 **))
     __nonnull ((1, 2));
# endif

# ifdef __USE_GNU
/* Similar to `scandir' but a relative DIR name is interpreted relative
   to the directory for which DFD is a descriptor.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
#  ifndef __USE_FILE_OFFSET64
extern int scandirat (int __dfd, const char *__restrict __dir,
		      struct dirent ***__restrict __namelist,
		      int (*__selector) (const struct dirent *),
		      int (*__cmp) (const struct dirent **,
				    const struct dirent **))
     __nonnull ((2, 3));
#  else
#   ifdef __REDIRECT
extern int __REDIRECT (scandirat,
		       (int __dfd, const char *__restrict __dir,
			struct dirent ***__restrict __namelist,
			int (*__selector) (const struct dirent *),
			int (*__cmp) (const struct dirent **,
				      const struct dirent **)),
		       scandirat64) __nonnull ((2, 3));
#   else
#    define scandirat scandirat64
#   endif
#  endif

/* This function is like `scandir' but it uses the 64bit dirent structure.
   Please note that the CMP function must now work with struct dirent64 **.  */
extern int scandirat64 (int __dfd, const char *__restrict __dir,
			struct dirent64 ***__restrict __namelist,
			int (*__selector) (const struct dirent64 *),
			int (*__cmp) (const struct dirent64 **,
				      const struct dirent64 **))
     __nonnull ((2, 3));
# endif

/* Function to compare two `struct dirent's alphabetically.  */
# ifndef __USE_FILE_OFFSET64
extern int alphasort (const struct dirent **__e1,
		      const struct dirent **__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
# else
#  ifdef __REDIRECT
extern int __REDIRECT_NTH (alphasort,
			   (const struct dirent **__e1,
			    const struct dirent **__e2),
			   alphasort64) __attribute_pure__ __nonnull ((1, 2));
#  else
#   define alphasort alphasort64
#  endif
# endif

# if defined __USE_GNU && defined __USE_LARGEFILE64
extern int alphasort64 (const struct dirent64 **__e1,
			const struct dirent64 **__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
# endif
#endif /* Use XPG7.  */


#ifdef __USE_MISC
/* Read directory entries from FD into BUF, reading at most NBYTES.
   Reading starts at offset *BASEP, and *BASEP is updated with the new
   position after reading.  Returns the number of bytes read; zero when at
   end of directory; or -1 for errors.  */
# ifndef __USE_FILE_OFFSET64
extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
				size_t __nbytes,
				__off_t *__restrict __basep)
     __THROW __nonnull ((2, 4));
# else
#  ifdef __REDIRECT
extern __ssize_t __REDIRECT_NTH (getdirentries,
				 (int __fd, char *__restrict __buf,
				  size_t __nbytes,
				  __off64_t *__restrict __basep),
				 getdirentries64) __nonnull ((2, 4));
#  else
#   define getdirentries getdirentries64
#  endif
# endif

# ifdef __USE_LARGEFILE64
extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
				  size_t __nbytes,
				  __off64_t *__restrict __basep)
     __THROW __nonnull ((2, 4));
# endif
#endif /* Use misc.  */

#ifdef __USE_GNU
/* Function to compare two `struct dirent's by name & version.  */
# ifndef __USE_FILE_OFFSET64
extern int versionsort (const struct dirent **__e1,
			const struct dirent **__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
# else
#  ifdef __REDIRECT
extern int __REDIRECT_NTH (versionsort,
			   (const struct dirent **__e1,
			    const struct dirent **__e2),
			   versionsort64)
     __attribute_pure__ __nonnull ((1, 2));
#  else
#   define versionsort versionsort64
#  endif
# endif

# ifdef __USE_LARGEFILE64
extern int versionsort64 (const struct dirent64 **__e1,
			  const struct dirent64 **__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
# endif
#endif /* Use GNU.  */

__END_DECLS

#include <bits/dirent_ext.h>

#endif /* dirent.h  */
Commit	Line	Data
04277e02	1	/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
54d79e99	2	This file is part of the GNU C Library.
28f540f4	3
54d79e99	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	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.
28f540f4	8
54d79e99 UD	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
41bdb6e2	12	Lesser General Public License for more details.
28f540f4	13
41bdb6e2	14	You should have received a copy of the GNU Lesser General Public
59ba27a6	15	License along with the GNU C Library; if not, see
5a82c748	16	<https://www.gnu.org/licenses/>. */
28f540f4 RM	17
	18	/*
	19	* POSIX Standard: 5.1.2 Directory Operations <dirent.h>
	20	*/
	21
	22	#ifndef _DIRENT_H
28f540f4	23	#define _DIRENT_H 1
5107cf1d	24
28f540f4 RM	25	#include <features.h>
	26
	27	__BEGIN_DECLS
	28
5107cf1d	29	#include <bits/types.h>
28f540f4	30
70b2845f UD	31	#ifdef __USE_XOPEN
	32	# ifndef __ino_t_defined
	33	# ifndef __USE_FILE_OFFSET64
	34	typedef __ino_t ino_t;
	35	# else
	36	typedef __ino64_t ino_t;
	37	# endif
	38	# define __ino_t_defined
	39	# endif
8353b5f6	40	# if defined __USE_LARGEFILE64 && !defined __ino64_t_defined
70b2845f	41	typedef __ino64_t ino64_t;
8353b5f6	42	# define __ino64_t_defined
70b2845f UD	43	# endif
	44	#endif
	45
92777700	46	/* This file defines `struct dirent'.
bfc04a9f	47
92777700 RM	48	It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen'
92777700 RM	49	member that gives the length of `d_name'.
bfc04a9f	50
92777700	51	It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen'
a1470b6f RM	52	member that gives the size of the entire directory entry.
	53
	54	It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off'
	55	member that gives the file offset of the next directory entry.
c0e45674 UD	56
	57	It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type'
	58	member that gives the type of the file.
a1470b6f	59	*/
bfc04a9f	60
5107cf1d	61	#include <bits/dirent.h>
28f540f4	62
ed9a38e2	63	#if defined __USE_MISC && !defined d_fileno
c0e45674	64	# define d_ino d_fileno /* Backward compatibility. */
28f540f4 RM	65	#endif
28f540f4 RM	66
92777700 RM	67	/* These macros extract size information from a `struct dirent *'.
	68	They may evaluate their argument multiple times, so it must not
	69	have side effects. Each of these may involve a relatively costly
	70	call to `strlen' on some systems, so these values should be cached.
	71
	72	_D_EXACT_NAMLEN (DP) returns the length of DP->d_name, not including
	73	its terminating null character.
	74
	75	_D_ALLOC_NAMLEN (DP) returns a size at least (_D_EXACT_NAMLEN (DP) + 1);
	76	that is, the allocation size needed to hold the DP->d_name string.
	77	Use this macro when you don't need the exact length, just an upper bound.
	78	This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN.
	79	*/
	80
	81	#ifdef _DIRENT_HAVE_D_NAMLEN
c0e45674 UD	82	# define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
c0e45674 UD	83	# define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
92777700	84	#else
c0e45674 UD	85	# define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name))
	86	# ifdef _DIRENT_HAVE_D_RECLEN
	87	# define _D_ALLOC_NAMLEN(d) (((char *) (d) + (d)->d_reclen) - &(d)->d_name[0])
	88	# else
a04549c1 JM	89	# define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name \
a04549c1 JM	90	: _D_EXACT_NAMLEN (d) + 1)
c0e45674	91	# endif
92777700 RM	92	#endif
	93
	94
498afc54	95	#ifdef __USE_MISC
28f540f4 RM	96	/* File types for `d_type'. */
	97	enum
	98	{
	99	DT_UNKNOWN = 0,
74015205	100	# define DT_UNKNOWN DT_UNKNOWN
28f540f4	101	DT_FIFO = 1,
74015205	102	# define DT_FIFO DT_FIFO
28f540f4	103	DT_CHR = 2,
74015205	104	# define DT_CHR DT_CHR
28f540f4	105	DT_DIR = 4,
74015205	106	# define DT_DIR DT_DIR
28f540f4	107	DT_BLK = 6,
74015205	108	# define DT_BLK DT_BLK
28f540f4	109	DT_REG = 8,
74015205	110	# define DT_REG DT_REG
28f540f4	111	DT_LNK = 10,
74015205	112	# define DT_LNK DT_LNK
21f6a100	113	DT_SOCK = 12,
74015205	114	# define DT_SOCK DT_SOCK
21f6a100 UD	115	DT_WHT = 14
21f6a100 UD	116	# define DT_WHT DT_WHT
28f540f4 RM	117	};
	118
	119	/* Convert between stat structure types and directory types. */
c0e45674 UD	120	# define IFTODT(mode) (((mode) & 0170000) >> 12)
c0e45674 UD	121	# define DTTOIF(dirtype) ((dirtype) << 12)
28f540f4 RM	122	#endif
	123
	124
18926cf4 RM	125	/* This is the data type of directory stream objects.
	126	The actual structure is opaque to users. */
	127	typedef struct __dirstream DIR;
28f540f4 RM	128
28f540f4 RM	129	/* Open a directory stream on NAME.
2c008571 UD	130	Return a DIR stream on the directory, or NULL if it could not be opened.
	131
	132	This function is a possible cancellation point and therefore not
	133	marked with __THROW. */
a784e502	134	extern DIR opendir (const char __name) __nonnull ((1));
28f540f4	135
77db439e	136	#ifdef __USE_XOPEN2K8
1812d50b UD	137	/* Same as opendir, but open the stream on the file descriptor FD.
	138
	139	This function is a possible cancellation point and therefore not
	140	marked with __THROW. */
	141	extern DIR *fdopendir (int __fd);
	142	#endif
	143
28f540f4	144	/* Close the directory stream DIRP.
2c008571 UD	145	Return 0 if successful, -1 if not.
	146
	147	This function is a possible cancellation point and therefore not
	148	marked with __THROW. */
b45ff182	149	extern int closedir (DIR *__dirp) __nonnull ((1));
28f540f4	150
dfd2257a UD	151	/* Read a directory entry from DIRP. Return a pointer to a `struct
	152	dirent' describing the entry, or NULL for EOF or error. The
	153	storage returned may be overwritten by a later readdir call on the
	154	same DIR stream.
	155
	156	If the Large File Support API is selected we have to use the
2c008571 UD	157	appropriate interface.
	158
	159	This function is a possible cancellation point and therefore not
	160	marked with __THROW. */
dfd2257a	161	#ifndef __USE_FILE_OFFSET64
b45ff182	162	extern struct dirent readdir (DIR __dirp) __nonnull ((1));
dfd2257a	163	#else
01cad722	164	# ifdef __REDIRECT
b45ff182 UD	165	extern struct dirent __REDIRECT (readdir, (DIR __dirp), readdir64)
b45ff182 UD	166	__nonnull ((1));
01cad722 UD	167	# else
	168	# define readdir readdir64
	169	# endif
dfd2257a UD	170	#endif
	171
	172	#ifdef __USE_LARGEFILE64
b45ff182	173	extern struct dirent64 readdir64 (DIR __dirp) __nonnull ((1));
dfd2257a	174	#endif
28f540f4	175
acd7f096	176	#ifdef __USE_POSIX
6d52618b	177	/* Reentrant version of `readdir'. Return in RESULT a pointer to the
2c008571 UD	178	next entry.
	179
	180	This function is a possible cancellation point and therefore not
	181	marked with __THROW. */
dfd2257a	182	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	183	extern int readdir_r (DIR *__restrict __dirp,
c1422e5b UD	184	struct dirent *__restrict __entry,
b45ff182	185	struct dirent **__restrict __result)
7584a3f9	186	__nonnull ((1, 2, 3)) __attribute_deprecated__;
dfd2257a	187	# else
01cad722	188	# ifdef __REDIRECT
c1422e5b UD	189	extern int __REDIRECT (readdir_r,
	190	(DIR *__restrict __dirp,
	191	struct dirent *__restrict __entry,
2c008571	192	struct dirent **__restrict __result),
7584a3f9 FW	193	readdir64_r)
7584a3f9 FW	194	__nonnull ((1, 2, 3)) __attribute_deprecated__;
01cad722 UD	195	# else
	196	# define readdir_r readdir64_r
	197	# endif
dfd2257a UD	198	# endif
	199
	200	# ifdef __USE_LARGEFILE64
c1422e5b UD	201	extern int readdir64_r (DIR *__restrict __dirp,
c1422e5b UD	202	struct dirent64 *__restrict __entry,
b45ff182	203	struct dirent64 **__restrict __result)
7584a3f9	204	__nonnull ((1, 2, 3)) __attribute_deprecated__;
dfd2257a	205	# endif
c0e45674	206	#endif /* POSIX or misc */
d68171ed	207
28f540f4	208	/* Rewind DIRP to the beginning of the directory. */
b45ff182	209	extern void rewinddir (DIR *__dirp) __THROW __nonnull ((1));
28f540f4	210
ed9a38e2	211	#if defined __USE_MISC \|\| defined __USE_XOPEN
40a55d20 UD	212	# include <bits/types.h>
	213
	214	/* Seek to position POS on DIRP. */
b45ff182	215	extern void seekdir (DIR *__dirp, long int __pos) __THROW __nonnull ((1));
40a55d20 UD	216
40a55d20 UD	217	/* Return the current position of DIRP. */
b45ff182	218	extern long int telldir (DIR *__dirp) __THROW __nonnull ((1));
40a55d20 UD	219	#endif
40a55d20 UD	220
acd7f096	221	#ifdef __USE_XOPEN2K8
28f540f4	222
22a1292a	223	/* Return the file descriptor used by DIRP. */
b45ff182	224	extern int dirfd (DIR *__dirp) __THROW __nonnull ((1));
22a1292a	225
c0e45674 UD	226	# if defined __OPTIMIZE__ && defined _DIR_dirfd
	227	# define dirfd(dirp) _DIR_dirfd (dirp)
	228	# endif
22a1292a	229
ed9a38e2	230	# ifdef __USE_MISC
77db439e	231	# ifndef MAXNAMLEN
28f540f4	232	/* Get the definitions of the POSIX.1 limits. */
5107cf1d	233	# include <bits/posix1_lim.h>
28f540f4 RM	234
28f540f4 RM	235	/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'. */
77db439e UD	236	# ifdef NAME_MAX
	237	# define MAXNAMLEN NAME_MAX
	238	# else
	239	# define MAXNAMLEN 255
	240	# endif
c0e45674 UD	241	# endif
	242	# endif
	243
c0e45674 UD	244	# define __need_size_t
c0e45674 UD	245	# include <stddef.h>
28f540f4	246
afd4eb37	247	/* Scan the directory DIR, calling SELECTOR on each directory entry.
28f540f4 RM	248	Entries for which SELECT returns nonzero are individually malloc'd,
28f540f4 RM	249	sorted using qsort with CMP, and collected in a malloc'd array in
c55fbd1e UD	250	*NAMELIST. Returns the number of entries selected, or -1 on error.
	251
	252	This function is a cancellation point and therefore not marked with
	253	__THROW. */
89a9e37b	254	# ifndef __USE_FILE_OFFSET64
a784e502	255	extern int scandir (const char *__restrict __dir,
c1422e5b	256	struct dirent ***__restrict __namelist,
a784e502 UD	257	int (__selector) (const struct dirent ),
	258	int (__cmp) (const struct dirent *,
	259	const struct dirent **))
b45ff182	260	__nonnull ((1, 2));
89a9e37b	261	# else
01cad722 UD	262	# ifdef __REDIRECT
01cad722 UD	263	extern int __REDIRECT (scandir,
a784e502	264	(const char *__restrict __dir,
c1422e5b	265	struct dirent ***__restrict __namelist,
a784e502 UD	266	int (__selector) (const struct dirent ),
	267	int (__cmp) (const struct dirent *,
	268	const struct dirent **)),
b45ff182	269	scandir64) __nonnull ((1, 2));
01cad722 UD	270	# else
	271	# define scandir scandir64
	272	# endif
89a9e37b UD	273	# endif
	274
	275	# if defined __USE_GNU && defined __USE_LARGEFILE64
	276	/* This function is like `scandir' but it uses the 64bit dirent structure.
	277	Please note that the CMP function must now work with struct dirent64 *. /
a784e502	278	extern int scandir64 (const char *__restrict __dir,
c1422e5b	279	struct dirent64 ***__restrict __namelist,
a784e502 UD	280	int (__selector) (const struct dirent64 ),
	281	int (__cmp) (const struct dirent64 *,
	282	const struct dirent64 **))
b45ff182	283	__nonnull ((1, 2));
89a9e37b	284	# endif
28f540f4	285
c55fbd1e UD	286	# ifdef __USE_GNU
	287	/* Similar to `scandir' but a relative DIR name is interpreted relative
	288	to the directory for which DFD is a descriptor.
	289
	290	This function is a cancellation point and therefore not marked with
	291	__THROW. */
	292	# ifndef __USE_FILE_OFFSET64
a784e502	293	extern int scandirat (int __dfd, const char *__restrict __dir,
c55fbd1e	294	struct dirent ***__restrict __namelist,
a784e502 UD	295	int (__selector) (const struct dirent ),
	296	int (__cmp) (const struct dirent *,
	297	const struct dirent **))
c55fbd1e UD	298	__nonnull ((2, 3));
	299	# else
	300	# ifdef __REDIRECT
	301	extern int __REDIRECT (scandirat,
a784e502	302	(int __dfd, const char *__restrict __dir,
c55fbd1e	303	struct dirent ***__restrict __namelist,
a784e502 UD	304	int (__selector) (const struct dirent ),
	305	int (__cmp) (const struct dirent *,
	306	const struct dirent **)),
c55fbd1e UD	307	scandirat64) __nonnull ((2, 3));
	308	# else
	309	# define scandirat scandirat64
	310	# endif
	311	# endif
	312
	313	/* This function is like `scandir' but it uses the 64bit dirent structure.
	314	Please note that the CMP function must now work with struct dirent64 *. /
a784e502	315	extern int scandirat64 (int __dfd, const char *__restrict __dir,
c55fbd1e	316	struct dirent64 ***__restrict __namelist,
a784e502 UD	317	int (__selector) (const struct dirent64 ),
	318	int (__cmp) (const struct dirent64 *,
	319	const struct dirent64 **))
c55fbd1e UD	320	__nonnull ((2, 3));
	321	# endif
	322
28f540f4	323	/* Function to compare two `struct dirent's alphabetically. */
89a9e37b	324	# ifndef __USE_FILE_OFFSET64
a784e502 UD	325	extern int alphasort (const struct dirent **__e1,
a784e502 UD	326	const struct dirent **__e2)
b45ff182	327	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	328	# else
01cad722	329	# ifdef __REDIRECT
f377d022	330	extern int __REDIRECT_NTH (alphasort,
a784e502 UD	331	(const struct dirent **__e1,
a784e502 UD	332	const struct dirent **__e2),
b45ff182	333	alphasort64) __attribute_pure__ __nonnull ((1, 2));
01cad722 UD	334	# else
	335	# define alphasort alphasort64
	336	# endif
89a9e37b UD	337	# endif
	338
	339	# if defined __USE_GNU && defined __USE_LARGEFILE64
a784e502 UD	340	extern int alphasort64 (const struct dirent64 **__e1,
a784e502 UD	341	const struct dirent64 **__e2)
b45ff182	342	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	343	# endif
acd7f096	344	#endif /* Use XPG7. */
28f540f4 RM	345
28f540f4 RM	346
ed9a38e2	347	#ifdef __USE_MISC
28f540f4 RM	348	/* Read directory entries from FD into BUF, reading at most NBYTES.
	349	Reading starts at offset BASEP, and BASEP is updated with the new
	350	position after reading. Returns the number of bytes read; zero when at
	351	end of directory; or -1 for errors. */
eee6b143	352	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	353	extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
c1422e5b UD	354	size_t __nbytes,
b45ff182 UD	355	__off_t *__restrict __basep)
b45ff182 UD	356	__THROW __nonnull ((2, 4));
eee6b143 UD	357	# else
eee6b143 UD	358	# ifdef __REDIRECT
f377d022 UD	359	extern __ssize_t __REDIRECT_NTH (getdirentries,
	360	(int __fd, char *__restrict __buf,
	361	size_t __nbytes,
	362	__off64_t *__restrict __basep),
b45ff182	363	getdirentries64) __nonnull ((2, 4));
eee6b143 UD	364	# else
eee6b143 UD	365	# define getdirentries getdirentries64
e5cd813b	366	# endif
eee6b143	367	# endif
28f540f4	368
eee6b143	369	# ifdef __USE_LARGEFILE64
c1422e5b UD	370	extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
c1422e5b UD	371	size_t __nbytes,
b45ff182 UD	372	__off64_t *__restrict __basep)
b45ff182 UD	373	__THROW __nonnull ((2, 4));
eee6b143	374	# endif
acd7f096	375	#endif /* Use misc. */
77db439e UD	376
	377	#ifdef __USE_GNU
	378	/* Function to compare two `struct dirent's by name & version. */
	379	# ifndef __USE_FILE_OFFSET64
a784e502 UD	380	extern int versionsort (const struct dirent **__e1,
a784e502 UD	381	const struct dirent **__e2)
77db439e UD	382	__THROW __attribute_pure__ __nonnull ((1, 2));
	383	# else
	384	# ifdef __REDIRECT
	385	extern int __REDIRECT_NTH (versionsort,
a784e502 UD	386	(const struct dirent **__e1,
a784e502 UD	387	const struct dirent **__e2),
77db439e UD	388	versionsort64)
	389	__attribute_pure__ __nonnull ((1, 2));
	390	# else
	391	# define versionsort versionsort64
	392	# endif
e5cd813b	393	# endif
28f540f4	394
77db439e	395	# ifdef __USE_LARGEFILE64
a784e502 UD	396	extern int versionsort64 (const struct dirent64 **__e1,
a784e502 UD	397	const struct dirent64 **__e2)
77db439e UD	398	__THROW __attribute_pure__ __nonnull ((1, 2));
	399	# endif
	400	#endif /* Use GNU. */
28f540f4 RM	401
	402	__END_DECLS
	403
b8b3d5a1 FW	404	#include <bits/dirent_ext.h>
b8b3d5a1 FW	405
28f540f4	406	#endif /* dirent.h */