Back to index

glibc  2.9
Classes | Defines | Functions
getdents.c File Reference
#include <alloca.h>
#include <assert.h>
#include <errno.h>
#include <dirent.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sysdep.h>
#include <sys/syscall.h>
#include <bp-checks.h>
#include <linux/posix_types.h>
#include <kernel-features.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  kernel_dirent
struct  kernel_dirent64

Defines

#define __have_no_getdents64   0
#define __GETDENTS   __getdents
#define DIRENT_TYPE   struct dirent
#define DIRENT_SET_DP_INO(dp, value)   (dp)->d_ino = (value)

Functions

ssize_t internal_function __GETDENTS (int fd, char *buf, size_t nbytes)

Class Documentation

struct kernel_dirent

Definition at line 39 of file getdents.c.

Class Members
ino_t d_ino
long int d_ino
char d_name
off_t d_off
__kernel_off_t d_off
unsigned short int d_reclen
struct kernel_dirent64

Definition at line 69 of file getdents.c.

Class Members
uint64_t d_ino
char d_name
int64_t d_off
unsigned short int d_reclen
unsigned char d_type

Define Documentation

#define __GETDENTS   __getdents

Definition at line 79 of file getdents.c.

#define __have_no_getdents64   0

Definition at line 51 of file getdents.c.

#define DIRENT_SET_DP_INO (   dp,
  value 
)    (dp)->d_ino = (value)

Definition at line 85 of file getdents.c.

#define DIRENT_TYPE   struct dirent

Definition at line 82 of file getdents.c.


Function Documentation

ssize_t internal_function __GETDENTS ( int  fd,
char *  buf,
size_t  nbytes 
)

Definition at line 98 of file getdents.c.

{
  ssize_t retval;

#ifdef __ASSUME_GETDENTS32_D_TYPE
  if (sizeof (DIRENT_TYPE) == sizeof (struct dirent))
    {
      retval = INLINE_SYSCALL (getdents, 3, fd, CHECK_N(buf, nbytes), nbytes);

      /* The kernel added the d_type value after the name.  Change
        this now.  */
      if (retval != -1)
       {
         union
         {
           struct kernel_dirent k;
           struct dirent u;
         } *kbuf = (void *) buf;

         while ((char *) kbuf < buf + retval)
           {
             char d_type = *((char *) kbuf + kbuf->k.d_reclen - 1);
             memmove (kbuf->u.d_name, kbuf->k.d_name,
                     strlen (kbuf->k.d_name) + 1);
             kbuf->u.d_type = d_type;

             kbuf = (void *) ((char *) kbuf + kbuf->k.d_reclen);
           }
       }

      return retval;
    }
#endif

  off64_t last_offset = -1;

#ifdef __NR_getdents64
  if (!__have_no_getdents64)
    {
# ifndef __ASSUME_GETDENTS64_SYSCALL
      int saved_errno = errno;
# endif
      union
      {
       struct kernel_dirent64 k;
       DIRENT_TYPE u;
       char b[1];
      } *kbuf = (void *) buf, *outp, *inp;
      size_t kbytes = nbytes;
      if (offsetof (DIRENT_TYPE, d_name)
         < offsetof (struct kernel_dirent64, d_name)
         && nbytes <= sizeof (DIRENT_TYPE))
       {
         kbytes = nbytes + offsetof (struct kernel_dirent64, d_name)
                 - offsetof (DIRENT_TYPE, d_name);
         kbuf = __alloca(kbytes);
       }
      retval = INLINE_SYSCALL (getdents64, 3, fd, CHECK_N(kbuf, kbytes),
                            kbytes);
# ifndef __ASSUME_GETDENTS64_SYSCALL
      if (retval != -1 || (errno != EINVAL && errno != ENOSYS))
# endif
       {
         const size_t size_diff = (offsetof (struct kernel_dirent64, d_name)
                                - offsetof (DIRENT_TYPE, d_name));

         /* Return the error if encountered.  */
         if (retval == -1)
           return -1;

         /* If the structure returned by the kernel is identical to what we
            need, don't do any conversions.  */
         if (offsetof (DIRENT_TYPE, d_name)
             == offsetof (struct kernel_dirent64, d_name)
             && sizeof (outp->u.d_ino) == sizeof (inp->k.d_ino)
             && sizeof (outp->u.d_off) == sizeof (inp->k.d_off))
           return retval;

         /* These two pointers might alias the same memory buffer.
            Standard C requires that we always use the same type for them,
            so we must use the union type.  */
         inp = kbuf;
         outp = (void *) buf;

         while (&inp->b < &kbuf->b + retval)
           {
             const size_t alignment = __alignof__ (DIRENT_TYPE);
             /* Since inp->k.d_reclen is already aligned for the kernel
               structure this may compute a value that is bigger
               than necessary.  */
             size_t old_reclen = inp->k.d_reclen;
             size_t new_reclen = ((old_reclen - size_diff + alignment - 1)
                              & ~(alignment - 1));

             /* Copy the data out of the old structure into temporary space.
               Then copy the name, which may overlap if BUF == KBUF.  */
             const uint64_t d_ino = inp->k.d_ino;
             const int64_t d_off = inp->k.d_off;
             const uint8_t d_type = inp->k.d_type;

             memmove (outp->u.d_name, inp->k.d_name,
                     old_reclen - offsetof (struct kernel_dirent64, d_name));

             /* Now we have copied the data from INP and access only OUTP.  */

             DIRENT_SET_DP_INO (&outp->u, d_ino);
             outp->u.d_off = d_off;
             if ((sizeof (outp->u.d_ino) != sizeof (inp->k.d_ino)
                 && outp->u.d_ino != d_ino)
                || (sizeof (outp->u.d_off) != sizeof (inp->k.d_off)
                    && outp->u.d_off != d_off))
              {
                /* Overflow.  If there was at least one entry
                   before this one, return them without error,
                   otherwise signal overflow.  */
                if (last_offset != -1)
                  {
                    __lseek64 (fd, last_offset, SEEK_SET);
                    return outp->b - buf;
                  }
                __set_errno (EOVERFLOW);
                return -1;
              }

             last_offset = d_off;
             outp->u.d_reclen = new_reclen;
             outp->u.d_type = d_type;

             inp = (void *) inp + old_reclen;
             outp = (void *) outp + new_reclen;
           }

         return outp->b - buf;
       }

# ifndef __ASSUME_GETDENTS64_SYSCALL
      __set_errno (saved_errno);
      __have_no_getdents64 = 1;
# endif
    }
#endif
  {
    size_t red_nbytes;
    struct kernel_dirent *skdp, *kdp;
    const size_t size_diff = (offsetof (DIRENT_TYPE, d_name)
                           - offsetof (struct kernel_dirent, d_name));

    red_nbytes = MIN (nbytes
                    - ((nbytes / (offsetof (DIRENT_TYPE, d_name) + 14))
                      * size_diff),
                    nbytes - size_diff);

    skdp = kdp = __alloca (red_nbytes);

    retval = INLINE_SYSCALL (getdents, 3, fd,
                          CHECK_N ((char *) kdp, red_nbytes), red_nbytes);

    if (retval == -1)
      return -1;

    DIRENT_TYPE *dp = (DIRENT_TYPE *) buf;
    while ((char *) kdp < (char *) skdp + retval)
      {
       const size_t alignment = __alignof__ (DIRENT_TYPE);
       /* Since kdp->d_reclen is already aligned for the kernel structure
          this may compute a value that is bigger than necessary.  */
       size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1)
                          & ~(alignment - 1));
       if ((char *) dp + new_reclen > buf + nbytes)
         {
           /* Our heuristic failed.  We read too many entries.  Reset
              the stream.  */
           assert (last_offset != -1);
           __lseek64 (fd, last_offset, SEEK_SET);

           if ((char *) dp == buf)
             {
              /* The buffer the user passed in is too small to hold even
                 one entry.  */
              __set_errno (EINVAL);
              return -1;
             }

           break;
         }

       last_offset = kdp->d_off;
       DIRENT_SET_DP_INO(dp, kdp->d_ino);
       dp->d_off = kdp->d_off;
       dp->d_reclen = new_reclen;
       dp->d_type = DT_UNKNOWN;
       memcpy (dp->d_name, kdp->d_name,
              kdp->d_reclen - offsetof (struct kernel_dirent, d_name));

       dp = (DIRENT_TYPE *) ((char *) dp + new_reclen);
       kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen);
      }

    return (char *) dp - buf;
  }
}

Here is the call graph for this function: