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

/* Copyright (C) 1991-2000, 2003-2005, 2009 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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

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

#if defined __USE_POSIX || defined __USE_MISC
/* 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));
# 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));
#  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));
# endif
#endif	/* POSIX or misc */

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

#if defined __USE_BSD || 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

#if defined __USE_BSD || defined __USE_MISC || defined __XOPEN_2K8

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

# if defined __USE_BSD || defined __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.  */
# ifndef __USE_FILE_OFFSET64
extern int scandir (__const char *__restrict __dir,
		    struct dirent ***__restrict __namelist,
		    int (*__selector) (__const struct dirent *),
		    int (*__cmp) (__const void *, __const void *))
     __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 void *, __const void *)),
		       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 void *, __const void *))
     __nonnull ((1, 2));
# endif

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

# if defined __USE_GNU && defined __USE_LARGEFILE64
extern int alphasort64 (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
# endif


# if defined __USE_BSD || defined __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 BSD or misc.  */
#endif /* Use BSD or misc or XPG7.  */

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

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

__END_DECLS

#endif /* dirent.h  */
Commit	Line	Data
77db439e	1	/* Copyright (C) 1991-2000, 2003-2005, 2009 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 AJ	14	You should have received a copy of the GNU Lesser General Public
	15	License along with the GNU C Library; if not, write to the Free
	16	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	17	02111-1307 USA. */
28f540f4 RM	18
	19	/*
	20	* POSIX Standard: 5.1.2 Directory Operations <dirent.h>
	21	*/
	22
	23	#ifndef _DIRENT_H
28f540f4	24	#define _DIRENT_H 1
5107cf1d	25
28f540f4 RM	26	#include <features.h>
	27
	28	__BEGIN_DECLS
	29
5107cf1d	30	#include <bits/types.h>
28f540f4	31
70b2845f UD	32	#ifdef __USE_XOPEN
	33	# ifndef __ino_t_defined
	34	# ifndef __USE_FILE_OFFSET64
	35	typedef __ino_t ino_t;
	36	# else
	37	typedef __ino64_t ino_t;
	38	# endif
	39	# define __ino_t_defined
	40	# endif
8353b5f6	41	# if defined __USE_LARGEFILE64 && !defined __ino64_t_defined
70b2845f	42	typedef __ino64_t ino64_t;
8353b5f6	43	# define __ino64_t_defined
70b2845f UD	44	# endif
	45	#endif
	46
92777700	47	/* This file defines `struct dirent'.
bfc04a9f	48
92777700 RM	49	It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen'
92777700 RM	50	member that gives the length of `d_name'.
bfc04a9f	51
92777700	52	It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen'
a1470b6f RM	53	member that gives the size of the entire directory entry.
	54
	55	It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off'
	56	member that gives the file offset of the next directory entry.
c0e45674 UD	57
	58	It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type'
	59	member that gives the type of the file.
a1470b6f	60	*/
bfc04a9f	61
5107cf1d	62	#include <bits/dirent.h>
28f540f4	63
c0e45674 UD	64	#if (defined __USE_BSD \|\| defined __USE_MISC) && !defined d_fileno
c0e45674 UD	65	# define d_ino d_fileno /* Backward compatibility. */
28f540f4 RM	66	#endif
28f540f4 RM	67
92777700 RM	68	/* These macros extract size information from a `struct dirent *'.
	69	They may evaluate their argument multiple times, so it must not
	70	have side effects. Each of these may involve a relatively costly
	71	call to `strlen' on some systems, so these values should be cached.
	72
	73	_D_EXACT_NAMLEN (DP) returns the length of DP->d_name, not including
	74	its terminating null character.
	75
	76	_D_ALLOC_NAMLEN (DP) returns a size at least (_D_EXACT_NAMLEN (DP) + 1);
	77	that is, the allocation size needed to hold the DP->d_name string.
	78	Use this macro when you don't need the exact length, just an upper bound.
	79	This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN.
	80	*/
	81
	82	#ifdef _DIRENT_HAVE_D_NAMLEN
c0e45674 UD	83	# define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
c0e45674 UD	84	# define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
92777700	85	#else
c0e45674 UD	86	# define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name))
	87	# ifdef _DIRENT_HAVE_D_RECLEN
	88	# define _D_ALLOC_NAMLEN(d) (((char *) (d) + (d)->d_reclen) - &(d)->d_name[0])
	89	# else
	90	# define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name : \
	91	_D_EXACT_NAMLEN (d) + 1)
	92	# endif
92777700 RM	93	#endif
	94
	95
28f540f4 RM	96	#ifdef __USE_BSD
	97	/* File types for `d_type'. */
	98	enum
	99	{
	100	DT_UNKNOWN = 0,
74015205	101	# define DT_UNKNOWN DT_UNKNOWN
28f540f4	102	DT_FIFO = 1,
74015205	103	# define DT_FIFO DT_FIFO
28f540f4	104	DT_CHR = 2,
74015205	105	# define DT_CHR DT_CHR
28f540f4	106	DT_DIR = 4,
74015205	107	# define DT_DIR DT_DIR
28f540f4	108	DT_BLK = 6,
74015205	109	# define DT_BLK DT_BLK
28f540f4	110	DT_REG = 8,
74015205	111	# define DT_REG DT_REG
28f540f4	112	DT_LNK = 10,
74015205	113	# define DT_LNK DT_LNK
21f6a100	114	DT_SOCK = 12,
74015205	115	# define DT_SOCK DT_SOCK
21f6a100 UD	116	DT_WHT = 14
21f6a100 UD	117	# define DT_WHT DT_WHT
28f540f4 RM	118	};
	119
	120	/* Convert between stat structure types and directory types. */
c0e45674 UD	121	# define IFTODT(mode) (((mode) & 0170000) >> 12)
c0e45674 UD	122	# define DTTOIF(dirtype) ((dirtype) << 12)
28f540f4 RM	123	#endif
	124
	125
18926cf4 RM	126	/* This is the data type of directory stream objects.
	127	The actual structure is opaque to users. */
	128	typedef struct __dirstream DIR;
28f540f4 RM	129
28f540f4 RM	130	/* Open a directory stream on NAME.
2c008571 UD	131	Return a DIR stream on the directory, or NULL if it could not be opened.
	132
	133	This function is a possible cancellation point and therefore not
	134	marked with __THROW. */
b45ff182	135	extern DIR opendir (__const char __name) __nonnull ((1));
28f540f4	136
77db439e	137	#ifdef __USE_XOPEN2K8
1812d50b UD	138	/* Same as opendir, but open the stream on the file descriptor FD.
	139
	140	This function is a possible cancellation point and therefore not
	141	marked with __THROW. */
	142	extern DIR *fdopendir (int __fd);
	143	#endif
	144
28f540f4	145	/* Close the directory stream DIRP.
2c008571 UD	146	Return 0 if successful, -1 if not.
	147
	148	This function is a possible cancellation point and therefore not
	149	marked with __THROW. */
b45ff182	150	extern int closedir (DIR *__dirp) __nonnull ((1));
28f540f4	151
dfd2257a UD	152	/* Read a directory entry from DIRP. Return a pointer to a `struct
	153	dirent' describing the entry, or NULL for EOF or error. The
	154	storage returned may be overwritten by a later readdir call on the
	155	same DIR stream.
	156
	157	If the Large File Support API is selected we have to use the
2c008571 UD	158	appropriate interface.
	159
	160	This function is a possible cancellation point and therefore not
	161	marked with __THROW. */
dfd2257a	162	#ifndef __USE_FILE_OFFSET64
b45ff182	163	extern struct dirent readdir (DIR __dirp) __nonnull ((1));
dfd2257a	164	#else
01cad722	165	# ifdef __REDIRECT
b45ff182 UD	166	extern struct dirent __REDIRECT (readdir, (DIR __dirp), readdir64)
b45ff182 UD	167	__nonnull ((1));
01cad722 UD	168	# else
	169	# define readdir readdir64
	170	# endif
dfd2257a UD	171	#endif
	172
	173	#ifdef __USE_LARGEFILE64
b45ff182	174	extern struct dirent64 readdir64 (DIR __dirp) __nonnull ((1));
dfd2257a	175	#endif
28f540f4	176
c0e45674	177	#if defined __USE_POSIX \|\| defined __USE_MISC
6d52618b	178	/* Reentrant version of `readdir'. Return in RESULT a pointer to the
2c008571 UD	179	next entry.
	180
	181	This function is a possible cancellation point and therefore not
	182	marked with __THROW. */
dfd2257a	183	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	184	extern int readdir_r (DIR *__restrict __dirp,
c1422e5b UD	185	struct dirent *__restrict __entry,
b45ff182 UD	186	struct dirent **__restrict __result)
b45ff182 UD	187	__nonnull ((1, 2, 3));
dfd2257a	188	# else
01cad722	189	# ifdef __REDIRECT
c1422e5b UD	190	extern int __REDIRECT (readdir_r,
	191	(DIR *__restrict __dirp,
	192	struct dirent *__restrict __entry,
2c008571	193	struct dirent **__restrict __result),
b45ff182	194	readdir64_r) __nonnull ((1, 2, 3));
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 UD	203	struct dirent64 **__restrict __result)
b45ff182 UD	204	__nonnull ((1, 2, 3));
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
40a55d20 UD	211	#if defined __USE_BSD \|\| defined __USE_MISC \|\| defined __USE_XOPEN
	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
77db439e	221	#if defined __USE_BSD \|\| defined __USE_MISC \|\| defined __XOPEN_2K8
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
77db439e UD	230	# if defined __USE_BSD \|\| defined __USE_MISC
77db439e UD	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,
	249	sorted using qsort with CMP, and collected in a malloc'd array in
	250	NAMELIST. Returns the number of entries selected, or -1 on error. /
89a9e37b	251	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	252	extern int scandir (__const char *__restrict __dir,
	253	struct dirent ***__restrict __namelist,
	254	int (__selector) (__const struct dirent ),
b45ff182 UD	255	int (__cmp) (__const void , __const void *))
b45ff182 UD	256	__nonnull ((1, 2));
89a9e37b	257	# else
01cad722 UD	258	# ifdef __REDIRECT
01cad722 UD	259	extern int __REDIRECT (scandir,
c1422e5b UD	260	(__const char *__restrict __dir,
	261	struct dirent ***__restrict __namelist,
	262	int (__selector) (__const struct dirent ),
b6cfea12	263	int (__cmp) (__const void , __const void *)),
b45ff182	264	scandir64) __nonnull ((1, 2));
01cad722 UD	265	# else
	266	# define scandir scandir64
	267	# endif
89a9e37b UD	268	# endif
	269
	270	# if defined __USE_GNU && defined __USE_LARGEFILE64
	271	/* This function is like `scandir' but it uses the 64bit dirent structure.
	272	Please note that the CMP function must now work with struct dirent64 *. /
c1422e5b UD	273	extern int scandir64 (__const char *__restrict __dir,
	274	struct dirent64 ***__restrict __namelist,
	275	int (__selector) (__const struct dirent64 ),
b45ff182 UD	276	int (__cmp) (__const void , __const void *))
b45ff182 UD	277	__nonnull ((1, 2));
89a9e37b	278	# endif
28f540f4 RM	279
28f540f4 RM	280	/* Function to compare two `struct dirent's alphabetically. */
89a9e37b	281	# ifndef __USE_FILE_OFFSET64
fb4dfa0c	282	extern int alphasort (__const void __e1, __const void __e2)
b45ff182	283	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	284	# else
01cad722	285	# ifdef __REDIRECT
f377d022 UD	286	extern int __REDIRECT_NTH (alphasort,
f377d022 UD	287	(__const void __e1, __const void __e2),
b45ff182	288	alphasort64) __attribute_pure__ __nonnull ((1, 2));
01cad722 UD	289	# else
	290	# define alphasort alphasort64
	291	# endif
89a9e37b UD	292	# endif
	293
	294	# if defined __USE_GNU && defined __USE_LARGEFILE64
fb4dfa0c	295	extern int alphasort64 (__const void __e1, __const void __e2)
b45ff182	296	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	297	# endif
28f540f4 RM	298
28f540f4 RM	299
77db439e	300	# if defined __USE_BSD \|\| defined __USE_MISC
28f540f4 RM	301	/* Read directory entries from FD into BUF, reading at most NBYTES.
	302	Reading starts at offset BASEP, and BASEP is updated with the new
	303	position after reading. Returns the number of bytes read; zero when at
	304	end of directory; or -1 for errors. */
77db439e	305	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	306	extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
c1422e5b UD	307	size_t __nbytes,
b45ff182 UD	308	__off_t *__restrict __basep)
b45ff182 UD	309	__THROW __nonnull ((2, 4));
77db439e UD	310	# else
77db439e UD	311	# ifdef __REDIRECT
f377d022 UD	312	extern __ssize_t __REDIRECT_NTH (getdirentries,
	313	(int __fd, char *__restrict __buf,
	314	size_t __nbytes,
	315	__off64_t *__restrict __basep),
b45ff182	316	getdirentries64) __nonnull ((2, 4));
77db439e UD	317	# else
	318	# define getdirentries getdirentries64
	319	# endif
e5cd813b	320	# endif
28f540f4	321
77db439e	322	# ifdef __USE_LARGEFILE64
c1422e5b UD	323	extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
c1422e5b UD	324	size_t __nbytes,
b45ff182 UD	325	__off64_t *__restrict __basep)
b45ff182 UD	326	__THROW __nonnull ((2, 4));
77db439e UD	327	# endif
	328	# endif /* Use BSD or misc. */
	329	#endif /* Use BSD or misc or XPG7. */
	330
	331	#ifdef __USE_GNU
	332	/* Function to compare two `struct dirent's by name & version. */
	333	# ifndef __USE_FILE_OFFSET64
	334	extern int versionsort (__const void __e1, __const void __e2)
	335	__THROW __attribute_pure__ __nonnull ((1, 2));
	336	# else
	337	# ifdef __REDIRECT
	338	extern int __REDIRECT_NTH (versionsort,
	339	(__const void __e1, __const void __e2),
	340	versionsort64)
	341	__attribute_pure__ __nonnull ((1, 2));
	342	# else
	343	# define versionsort versionsort64
	344	# endif
e5cd813b	345	# endif
28f540f4	346
77db439e UD	347	# ifdef __USE_LARGEFILE64
	348	extern int versionsort64 (__const void __e1, __const void __e2)
	349	__THROW __attribute_pure__ __nonnull ((1, 2));
	350	# endif
	351	#endif /* Use GNU. */
28f540f4 RM	352
	353	__END_DECLS
	354
	355	#endif /* dirent.h */