lib/savedir.c

   1 /* savedir.c -- save the list of files in a directory in a string
   2
   3    Copyright (C) 1990, 1997-2001, 2003-2006, 2009-2020 Free Software
   4    Foundation, Inc.
   5
   6    This program is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 /* Written by David MacKenzie <djm@gnu.ai.mit.edu>. */
  20
  21 #include <config.h>
  22
  23 #include "savedir.h"
  24
  25 #include <sys/types.h>
  26
  27 #include <errno.h>
  28
  29 #include "dirent--.h"
  30 #ifndef _D_EXACT_NAMLEN
  31 # define _D_EXACT_NAMLEN(dp)    strlen ((dp)->d_name)
  32 #endif
  33
  34 #include <stddef.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "xalloc.h"
  39
  40 typedef struct
  41 {
  42   char *name;
  43 #if D_INO_IN_DIRENT
  44   ino_t ino;
  45 #endif
  46 } direntry_t;
  47
  48 /* Compare the names of two directory entries */
  49
  50 static int
  51 direntry_cmp_name (void const *a, void const *b)
  52 {
  53   direntry_t const *dea = a;
  54   direntry_t const *deb = b;
  55
  56   return strcmp (dea->name, deb->name);
  57 }
  58
  59 #if D_INO_IN_DIRENT
  60 /* Compare the inode numbers of two directory entries */
  61
  62 static int
  63 direntry_cmp_inode (void const *a, void const *b)
  64 {
  65   direntry_t const *dea = a;
  66   direntry_t const *deb = b;
  67
  68   return _GL_CMP (dea->ino, deb->ino);
  69 }
  70 #endif
  71
  72 typedef int (*comparison_function) (void const *, void const *);
  73
  74 static comparison_function const comparison_function_table[] =
  75   {
  76     0,
  77     direntry_cmp_name
  78 #if D_INO_IN_DIRENT
  79     , direntry_cmp_inode
  80 #endif
  81   };
  82
  83 /* Return a freshly allocated string containing the file names
  84    in directory DIRP, separated by '\0' characters;
  85    the end is marked by two '\0' characters in a row.
  86    Returned values are sorted according to OPTION.
  87    Return NULL (setting errno) if DIRP cannot be read.
  88    If DIRP is NULL, return NULL without affecting errno.  */
  89
  90 char *
  91 streamsavedir (DIR *dirp, enum savedir_option option)
  92 {
  93   char *name_space = NULL;
  94   size_t allocated = 0;
  95   direntry_t *entries = NULL;
  96   size_t entries_allocated = 0;
  97   size_t entries_used = 0;
  98   size_t used = 0;
  99   int readdir_errno;
 100   comparison_function cmp = comparison_function_table[option];
 101
 102   if (dirp == NULL)
 103     return NULL;
 104
 105   for (;;)
 106     {
 107       struct dirent const *dp;
 108       char const *entry;
 109
 110       errno = 0;
 111       dp = readdir (dirp);
 112       if (! dp)
 113         break;
 114
 115       /* Skip "", ".", and "..".  "" is returned by at least one buggy
 116          implementation: Solaris 2.4 readdir on NFS file systems.  */
 117       entry = dp->d_name;
 118       if (entry[entry[0] != '.' ? 0 : entry[1] != '.' ? 1 : 2] != '\0')
 119         {
 120           size_t entry_size = _D_EXACT_NAMLEN (dp) + 1;
 121           if (cmp)
 122             {
 123               if (entries_allocated == entries_used)
 124                 {
 125                   size_t n = entries_allocated;
 126                   entries = x2nrealloc (entries, &n, sizeof *entries);
 127                   entries_allocated = n;
 128                 }
 129               entries[entries_used].name = xstrdup (entry);
 130 #if D_INO_IN_DIRENT
 131               entries[entries_used].ino = dp->d_ino;
 132 #endif
 133               entries_used++;
 134             }
 135           else
 136             {
 137               if (allocated - used <= entry_size)
 138                 {
 139                   size_t n = used + entry_size;
 140                   if (n < used)
 141                     xalloc_die ();
 142                   name_space = x2nrealloc (name_space, &n, 1);
 143                   allocated = n;
 144                 }
 145               memcpy (name_space + used, entry, entry_size);
 146             }
 147           used += entry_size;
 148         }
 149     }
 150
 151   readdir_errno = errno;
 152   if (readdir_errno != 0)
 153     {
 154       free (entries);
 155       free (name_space);
 156       errno = readdir_errno;
 157       return NULL;
 158     }
 159
 160   if (cmp)
 161     {
 162       size_t i;
 163
 164       if (entries_used)
 165         qsort (entries, entries_used, sizeof *entries, cmp);
 166       name_space = xmalloc (used + 1);
 167       used = 0;
 168       for (i = 0; i < entries_used; i++)
 169         {
 170           char *dest = name_space + used;
 171           used += stpcpy (dest, entries[i].name) - dest + 1;
 172           free (entries[i].name);
 173         }
 174       free (entries);
 175     }
 176   else if (used == allocated)
 177     name_space = xrealloc (name_space, used + 1);
 178
 179   name_space[used] = '\0';
 180   return name_space;
 181 }
 182
 183 /* Return a freshly allocated string containing the file names
 184    in directory DIR, separated by '\0' characters;
 185    the end is marked by two '\0' characters in a row.
 186    Return NULL (setting errno) if DIR cannot be opened, read, or closed.  */
 187
 188 char *
 189 savedir (char const *dir, enum savedir_option option)
 190 {
 191   DIR *dirp = opendir (dir);
 192   if (! dirp)
 193     return NULL;
 194   else
 195     {
 196       char *name_space = streamsavedir (dirp, option);
 197       if (closedir (dirp) != 0)
 198         {
 199           int closedir_errno = errno;
 200           free (name_space);
 201           errno = closedir_errno;
 202           return NULL;
 203         }
 204       return name_space;
 205     }
 206 }