1  /* Copyright (C) 2001-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C Library is free software; you can redistribute it and/or
       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.
       8  
       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
      12     Lesser General Public License for more details.
      13  
      14     You should have received a copy of the GNU Lesser General Public
      15     License along with the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <dirent.h>
      19  #include <stddef.h>
      20  #include <string.h>
      21  #include <hurd.h>
      22  #include <hurd/fs.h>
      23  #include <hurd/fd.h>
      24  #include "dirstream.h"
      25  
      26  /* Read a directory entry from DIRP.  */
      27  int
      28  __readdir64_r (DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
      29  {
      30    struct dirent64 *dp;
      31    error_t err = 0;
      32  
      33    if (dirp == NULL)
      34      return __hurd_fail (EINVAL), EINVAL;
      35  
      36    __libc_lock_lock (dirp->__lock);
      37  
      38    do
      39      {
      40        if (dirp->__ptr - dirp->__data >= dirp->__size)
      41  	{
      42  	  /* We've emptied out our buffer.  Refill it.  */
      43  
      44  	  char *data = dirp->__data;
      45  	  mach_msg_type_number_t data_size = dirp->__size;
      46  	  int nentries;
      47  
      48  	  if (err = HURD_FD_PORT_USE (dirp->__fd,
      49  				      __dir_readdir (port,
      50  						     &data, &data_size,
      51  						     dirp->__entry_ptr,
      52  						     -1, 0, &nentries)))
      53  	    {
      54  	      __hurd_fail (err);
      55  	      dp = NULL;
      56  	      break;
      57  	    }
      58  
      59  	  dirp->__size = data_size;
      60  	  /* DATA now corresponds to entry index DIRP->__entry_ptr.  */
      61  	  dirp->__entry_data = dirp->__entry_ptr;
      62  
      63  	  if (data != dirp->__data)
      64  	    {
      65  	      /* The data was passed out of line, so our old buffer is no
      66  		 longer useful.  Deallocate the old buffer and reset our
      67  		 information for the new buffer.  */
      68  	      __vm_deallocate (__mach_task_self (),
      69  			       (vm_address_t) dirp->__data,
      70  			       dirp->__allocation);
      71  	      dirp->__data = data;
      72  	      dirp->__allocation = round_page (dirp->__size);
      73  	    }
      74  
      75  	  /* Reset the pointer into the buffer.  */
      76  	  dirp->__ptr = dirp->__data;
      77  
      78  	  if (nentries == 0)
      79  	    {
      80  	      /* End of file.  */
      81  	      dp = NULL;
      82  	      break;
      83  	    }
      84  
      85  	  /* We trust the filesystem to return correct data and so we
      86  	     ignore NENTRIES.  */
      87  	}
      88  
      89        dp = (struct dirent64 *) dirp->__ptr;
      90        dirp->__ptr += dp->d_reclen;
      91        ++dirp->__entry_ptr;
      92  
      93        /* Loop to ignore deleted files.  */
      94      } while (dp->d_fileno == 0);
      95  
      96    if (dp)
      97      {
      98        *entry = *dp;
      99        memcpy (entry->d_name, dp->d_name, dp->d_namlen + 1);
     100        *result = entry;
     101      }
     102    else
     103      *result = NULL;
     104  
     105    __libc_lock_unlock (dirp->__lock);
     106  
     107    return dp ? 0 : err ? errno : 0;
     108  }
     109  
     110  weak_alias (__readdir64_r, readdir64_r)