l4/pkg/l4re-core/uclibc/lib/contrib/uclibc/libc/sysdeps/linux/common/getdents.c

   1 /*
   2  * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
   3  *
   4  * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
   5  */
   6
   7 #include <sys/syscall.h>
   8 #include <bits/wordsize.h>
   9
  10 #if !(defined __UCLIBC_HAS_LFS__ && defined __NR_getdents64 && __WORDSIZE == 64)
  11
  12 #include <dirent.h>
  13 #include <string.h>
  14 #include <sys/types.h>
  15 #include <bits/kernel_types.h>
  16 #include <bits/kernel-features.h>
  17
  18 /* If the condition above is met, __getdents is defined as an alias
  19  * for __getdents64 (see getdents64.c). Otherwise...
  20  */
  21
  22 /* With newer versions of linux, the getdents syscall returns d_type
  23  * information after the name field.
  24  *
  25  * See __ASSUME_GETDENTS32_D_TYPE in glibc's kernel-features.h for specific
  26  * version / arch details.
  27  */
  28
  29 # ifdef __ARCH_HAS_DEPRECATED_SYSCALLS__
  30 struct kernel_dirent
  31 {
  32         long int d_ino;
  33         __kernel_off_t d_off;
  34         unsigned short int d_reclen;
  35         char d_name[256];
  36 };
  37 # else
  38 #  define kernel_dirent dirent
  39 # endif
  40
  41 # if defined __NR_getdents
  42 #  define __NR___syscall_getdents __NR_getdents
  43 static __always_inline _syscall3(int, __syscall_getdents, int, fd, unsigned char *, kdirp, size_t, count)
  44 # endif
  45
  46 # if defined __ASSUME_GETDENTS32_D_TYPE && defined __NR_getdents
  47
  48 ssize_t __getdents (int fd, char *buf, size_t nbytes)
  49 {
  50         ssize_t retval;
  51
  52         retval = __syscall_getdents(fd, (unsigned char *)buf, nbytes);
  53
  54         /* The kernel added the d_type value after the name.  Change
  55         this now.  */
  56         if (retval != -1) {
  57                 union {
  58                         struct kernel_dirent k;
  59                         struct dirent u;
  60                 } *kbuf = (void *) buf;
  61
  62                 while ((char *) kbuf < buf + retval) {
  63                         char d_type = *((char *) kbuf + kbuf->k.d_reclen - 1);
  64                         memmove (kbuf->u.d_name, kbuf->k.d_name,
  65                         strlen (kbuf->k.d_name) + 1);
  66                         kbuf->u.d_type = d_type;
  67
  68                         kbuf = (void *) ((char *) kbuf + kbuf->k.d_reclen);
  69                 }
  70         }
  71
  72         return retval;
  73 }
  74
  75 # elif ! defined __UCLIBC_HAS_LFS__ || !defined __NR_getdents64
  76
  77 #  include <assert.h>
  78 #  include <stddef.h>
  79 #  include <errno.h>
  80 #  include <unistd.h>
  81 #  include <sys/param.h>
  82 #  include <bits/uClibc_alloc.h>
  83
  84 ssize_t __getdents (int fd, char *buf, size_t nbytes)
  85 {
  86     struct dirent *dp;
  87     off_t last_offset = -1;
  88     ssize_t retval;
  89     size_t red_nbytes;
  90     struct kernel_dirent *skdp, *kdp;
  91     const size_t size_diff = (offsetof (struct dirent, d_name)
  92             - offsetof (struct kernel_dirent, d_name));
  93
  94 #  ifdef __ARCH_HAS_DEPRECATED_SYSCALLS__
  95     red_nbytes = MIN (nbytes - ((nbytes /
  96                     (offsetof (struct dirent, d_name) + 14)) * size_diff),
  97             nbytes - size_diff);
  98
  99     dp = (struct dirent *) buf;
 100     skdp = kdp = stack_heap_alloc(red_nbytes);
 101
 102     retval = __syscall_getdents(fd, (unsigned char *)kdp, red_nbytes);
 103 #  else
 104
 105     dp = (struct dirent *) buf;
 106     skdp = kdp = stack_heap_alloc(nbytes);
 107
 108     retval = INLINE_SYSCALL(getdents64, 3, fd, (unsigned char *)kdp, nbytes);
 109     if (retval > 0) {
 110             /* Did we overflow? */
 111             if (kdp->__pad1 || kdp->__pad2) {
 112                     __set_errno(EINVAL);
 113                     return -1;
 114             }
 115     }
 116 #  endif
 117
 118     if (retval == -1) {
 119         stack_heap_free(skdp);
 120         return -1;
 121     }
 122
 123     while ((char *) kdp < (char *) skdp + retval) {
 124         const size_t alignment = __alignof__ (struct dirent);
 125         /* Since kdp->d_reclen is already aligned for the kernel structure
 126            this may compute a value that is bigger than necessary.  */
 127         size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1)
 128                 & ~(alignment - 1));
 129         if ((char *) dp + new_reclen > buf + nbytes) {
 130             /* Our heuristic failed.  We read too many entries.  Reset
 131                the stream.  */
 132             assert (last_offset != -1);
 133             lseek(fd, last_offset, SEEK_SET);
 134
 135             if ((char *) dp == buf) {
 136                 /* The buffer the user passed in is too small to hold even
 137                    one entry.  */
 138                 stack_heap_free(skdp);
 139                 __set_errno (EINVAL);
 140                 return -1;
 141             }
 142             break;
 143         }
 144
 145         last_offset = kdp->d_off;
 146         dp->d_ino = kdp->d_ino;
 147         dp->d_off = kdp->d_off;
 148         dp->d_reclen = new_reclen;
 149         dp->d_type = DT_UNKNOWN;
 150         memcpy (dp->d_name, kdp->d_name,
 151                 kdp->d_reclen - offsetof (struct kernel_dirent, d_name));
 152         dp = (struct dirent *) ((char *) dp + new_reclen);
 153         kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen);
 154     }
 155     stack_heap_free(skdp);
 156     return (char *) dp - buf;
 157 }
 158
 159 # elif __WORDSIZE == 32 && !defined __NR_getdents64
 160
 161 #  include <stddef.h>
 162
 163 ssize_t __getdents (int fd, char *buf, size_t nbytes)
 164 {
 165     struct dirent *dp;
 166     struct dirent64 *dp64;
 167     ssize_t ret = __getdents64 (fd, buf, nbytes);
 168
 169     if (ret <= 0)
 170         return ret;
 171
 172     dp64 = (struct dirent64 *) buf;
 173     buf += ret;
 174     while ((void *) dp64 < (void *) buf) {
 175         dp = (struct dirent *) dp64;
 176         dp->d_ino = dp64->d_ino;
 177         dp->d_off = dp64->d_off;
 178         dp->d_reclen = dp64->d_reclen;
 179         dp->d_type = dp64->d_type;
 180         memmove (dp->d_name, dp64->d_name, dp->d_reclen - offsetof (struct dirent64, d_name));
 181         memmove (dp64, dp, dp->d_reclen);
 182         dp64 = ((void *) dp64) + dp->d_reclen;
 183     }
 184
 185     return ret;
 186 }
 187
 188 # endif
 189
 190 # if defined __UCLIBC_HAS_LFS__ && ! defined __NR_getdents64
 191 strong_alias(__getdents,__getdents64)
 192 # endif
 193
 194 #endif