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

/* Copyright (C) 1991-2014 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/>.  */

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

#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_MISC || 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_MISC || defined __USE_MISC || defined __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

# if defined __USE_MISC || 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.

   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 BSD or misc or XPG7.  */


#if defined __USE_MISC || 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.  */

#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

#endif /* dirent.h  */
Commit	Line	Data
d4697bc9	1	/* Copyright (C) 1991-2014 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 PE	15	License along with the GNU C Library; if not, see
59ba27a6 PE	16	<http://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
498afc54	63	#if (defined __USE_MISC \|\| 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
	89	# define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name : \
	90	_D_EXACT_NAMLEN (d) + 1)
	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
c0e45674	176	#if defined __USE_POSIX \|\| defined __USE_MISC
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 UD	185	struct dirent **__restrict __result)
b45ff182 UD	186	__nonnull ((1, 2, 3));
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),
b45ff182	193	readdir64_r) __nonnull ((1, 2, 3));
01cad722 UD	194	# else
	195	# define readdir_r readdir64_r
	196	# endif
dfd2257a UD	197	# endif
	198
	199	# ifdef __USE_LARGEFILE64
c1422e5b UD	200	extern int readdir64_r (DIR *__restrict __dirp,
c1422e5b UD	201	struct dirent64 *__restrict __entry,
b45ff182 UD	202	struct dirent64 **__restrict __result)
b45ff182 UD	203	__nonnull ((1, 2, 3));
dfd2257a	204	# endif
c0e45674	205	#endif /* POSIX or misc */
d68171ed	206
28f540f4	207	/* Rewind DIRP to the beginning of the directory. */
b45ff182	208	extern void rewinddir (DIR *__dirp) __THROW __nonnull ((1));
28f540f4	209
498afc54	210	#if defined __USE_MISC \|\| defined __USE_MISC \|\| defined __USE_XOPEN
40a55d20 UD	211	# include <bits/types.h>
	212
	213	/* Seek to position POS on DIRP. */
b45ff182	214	extern void seekdir (DIR *__dirp, long int __pos) __THROW __nonnull ((1));
40a55d20 UD	215
40a55d20 UD	216	/* Return the current position of DIRP. */
b45ff182	217	extern long int telldir (DIR *__dirp) __THROW __nonnull ((1));
40a55d20 UD	218	#endif
40a55d20 UD	219
498afc54	220	#if defined __USE_MISC \|\| defined __USE_MISC \|\| defined __USE_XOPEN2K8
28f540f4	221
22a1292a	222	/* Return the file descriptor used by DIRP. */
b45ff182	223	extern int dirfd (DIR *__dirp) __THROW __nonnull ((1));
22a1292a	224
c0e45674 UD	225	# if defined __OPTIMIZE__ && defined _DIR_dirfd
	226	# define dirfd(dirp) _DIR_dirfd (dirp)
	227	# endif
22a1292a	228
498afc54	229	# if defined __USE_MISC \|\| defined __USE_MISC
77db439e	230	# ifndef MAXNAMLEN
28f540f4	231	/* Get the definitions of the POSIX.1 limits. */
5107cf1d	232	# include <bits/posix1_lim.h>
28f540f4 RM	233
28f540f4 RM	234	/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'. */
77db439e UD	235	# ifdef NAME_MAX
	236	# define MAXNAMLEN NAME_MAX
	237	# else
	238	# define MAXNAMLEN 255
	239	# endif
c0e45674 UD	240	# endif
	241	# endif
	242
c0e45674 UD	243	# define __need_size_t
c0e45674 UD	244	# include <stddef.h>
28f540f4	245
afd4eb37	246	/* Scan the directory DIR, calling SELECTOR on each directory entry.
28f540f4 RM	247	Entries for which SELECT returns nonzero are individually malloc'd,
28f540f4 RM	248	sorted using qsort with CMP, and collected in a malloc'd array in
c55fbd1e UD	249	*NAMELIST. Returns the number of entries selected, or -1 on error.
	250
	251	This function is a cancellation point and therefore not marked with
	252	__THROW. */
89a9e37b	253	# ifndef __USE_FILE_OFFSET64
a784e502	254	extern int scandir (const char *__restrict __dir,
c1422e5b	255	struct dirent ***__restrict __namelist,
a784e502 UD	256	int (__selector) (const struct dirent ),
	257	int (__cmp) (const struct dirent *,
	258	const struct dirent **))
b45ff182	259	__nonnull ((1, 2));
89a9e37b	260	# else
01cad722 UD	261	# ifdef __REDIRECT
01cad722 UD	262	extern int __REDIRECT (scandir,
a784e502	263	(const char *__restrict __dir,
c1422e5b	264	struct dirent ***__restrict __namelist,
a784e502 UD	265	int (__selector) (const struct dirent ),
	266	int (__cmp) (const struct dirent *,
	267	const struct dirent **)),
b45ff182	268	scandir64) __nonnull ((1, 2));
01cad722 UD	269	# else
	270	# define scandir scandir64
	271	# endif
89a9e37b UD	272	# endif
	273
	274	# if defined __USE_GNU && defined __USE_LARGEFILE64
	275	/* This function is like `scandir' but it uses the 64bit dirent structure.
	276	Please note that the CMP function must now work with struct dirent64 *. /
a784e502	277	extern int scandir64 (const char *__restrict __dir,
c1422e5b	278	struct dirent64 ***__restrict __namelist,
a784e502 UD	279	int (__selector) (const struct dirent64 ),
	280	int (__cmp) (const struct dirent64 *,
	281	const struct dirent64 **))
b45ff182	282	__nonnull ((1, 2));
89a9e37b	283	# endif
28f540f4	284
c55fbd1e UD	285	# ifdef __USE_GNU
	286	/* Similar to `scandir' but a relative DIR name is interpreted relative
	287	to the directory for which DFD is a descriptor.
	288
	289	This function is a cancellation point and therefore not marked with
	290	__THROW. */
	291	# ifndef __USE_FILE_OFFSET64
a784e502	292	extern int scandirat (int __dfd, const char *__restrict __dir,
c55fbd1e	293	struct dirent ***__restrict __namelist,
a784e502 UD	294	int (__selector) (const struct dirent ),
	295	int (__cmp) (const struct dirent *,
	296	const struct dirent **))
c55fbd1e UD	297	__nonnull ((2, 3));
	298	# else
	299	# ifdef __REDIRECT
	300	extern int __REDIRECT (scandirat,
a784e502	301	(int __dfd, const char *__restrict __dir,
c55fbd1e	302	struct dirent ***__restrict __namelist,
a784e502 UD	303	int (__selector) (const struct dirent ),
	304	int (__cmp) (const struct dirent *,
	305	const struct dirent **)),
c55fbd1e UD	306	scandirat64) __nonnull ((2, 3));
	307	# else
	308	# define scandirat scandirat64
	309	# endif
	310	# endif
	311
	312	/* This function is like `scandir' but it uses the 64bit dirent structure.
	313	Please note that the CMP function must now work with struct dirent64 *. /
a784e502	314	extern int scandirat64 (int __dfd, const char *__restrict __dir,
c55fbd1e	315	struct dirent64 ***__restrict __namelist,
a784e502 UD	316	int (__selector) (const struct dirent64 ),
	317	int (__cmp) (const struct dirent64 *,
	318	const struct dirent64 **))
c55fbd1e UD	319	__nonnull ((2, 3));
	320	# endif
	321
28f540f4	322	/* Function to compare two `struct dirent's alphabetically. */
89a9e37b	323	# ifndef __USE_FILE_OFFSET64
a784e502 UD	324	extern int alphasort (const struct dirent **__e1,
a784e502 UD	325	const struct dirent **__e2)
b45ff182	326	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	327	# else
01cad722	328	# ifdef __REDIRECT
f377d022	329	extern int __REDIRECT_NTH (alphasort,
a784e502 UD	330	(const struct dirent **__e1,
a784e502 UD	331	const struct dirent **__e2),
b45ff182	332	alphasort64) __attribute_pure__ __nonnull ((1, 2));
01cad722 UD	333	# else
	334	# define alphasort alphasort64
	335	# endif
89a9e37b UD	336	# endif
	337
	338	# if defined __USE_GNU && defined __USE_LARGEFILE64
a784e502 UD	339	extern int alphasort64 (const struct dirent64 **__e1,
a784e502 UD	340	const struct dirent64 **__e2)
b45ff182	341	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	342	# endif
eee6b143	343	#endif /* Use BSD or misc or XPG7. */
28f540f4 RM	344
28f540f4 RM	345
498afc54	346	#if defined __USE_MISC \|\| defined __USE_MISC
28f540f4 RM	347	/* Read directory entries from FD into BUF, reading at most NBYTES.
	348	Reading starts at offset BASEP, and BASEP is updated with the new
	349	position after reading. Returns the number of bytes read; zero when at
	350	end of directory; or -1 for errors. */
eee6b143	351	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	352	extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
c1422e5b UD	353	size_t __nbytes,
b45ff182 UD	354	__off_t *__restrict __basep)
b45ff182 UD	355	__THROW __nonnull ((2, 4));
eee6b143 UD	356	# else
eee6b143 UD	357	# ifdef __REDIRECT
f377d022 UD	358	extern __ssize_t __REDIRECT_NTH (getdirentries,
	359	(int __fd, char *__restrict __buf,
	360	size_t __nbytes,
	361	__off64_t *__restrict __basep),
b45ff182	362	getdirentries64) __nonnull ((2, 4));
eee6b143 UD	363	# else
eee6b143 UD	364	# define getdirentries getdirentries64
e5cd813b	365	# endif
eee6b143	366	# endif
28f540f4	367
eee6b143	368	# ifdef __USE_LARGEFILE64
c1422e5b UD	369	extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
c1422e5b UD	370	size_t __nbytes,
b45ff182 UD	371	__off64_t *__restrict __basep)
b45ff182 UD	372	__THROW __nonnull ((2, 4));
eee6b143 UD	373	# endif
eee6b143 UD	374	#endif /* Use BSD or misc. */
77db439e UD	375
	376	#ifdef __USE_GNU
	377	/* Function to compare two `struct dirent's by name & version. */
	378	# ifndef __USE_FILE_OFFSET64
a784e502 UD	379	extern int versionsort (const struct dirent **__e1,
a784e502 UD	380	const struct dirent **__e2)
77db439e UD	381	__THROW __attribute_pure__ __nonnull ((1, 2));
	382	# else
	383	# ifdef __REDIRECT
	384	extern int __REDIRECT_NTH (versionsort,
a784e502 UD	385	(const struct dirent **__e1,
a784e502 UD	386	const struct dirent **__e2),
77db439e UD	387	versionsort64)
	388	__attribute_pure__ __nonnull ((1, 2));
	389	# else
	390	# define versionsort versionsort64
	391	# endif
e5cd813b	392	# endif
28f540f4	393
77db439e	394	# ifdef __USE_LARGEFILE64
a784e502 UD	395	extern int versionsort64 (const struct dirent64 **__e1,
a784e502 UD	396	const struct dirent64 **__e2)
77db439e UD	397	__THROW __attribute_pure__ __nonnull ((1, 2));
	398	# endif
	399	#endif /* Use GNU. */
28f540f4 RM	400
	401	__END_DECLS
	402
	403	#endif /* dirent.h */