glib/gdir.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * gdir.c: Simplified wrapper around the DIRENT functions.
   5  *
   6  * Copyright 2001 Hans Breuer
   7  * Copyright 2004 Tor Lillqvist
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <sys/stat.h>
  29
  30 #ifdef HAVE_DIRENT_H
  31 #include <sys/types.h>
  32 #include <dirent.h>
  33 #endif
  34
  35 #include "gdir.h"
  36
  37 #include "gconvert.h"
  38 #include "gfileutils.h"
  39 #include "gstrfuncs.h"
  40 #include "gtestutils.h"
  41 #include "glibintl.h"
  42
  43 #if defined (_MSC_VER) && !defined (HAVE_DIRENT_H)
  44 #include "../build/win32/dirent/dirent.h"
  45 #include "../build/win32/dirent/wdirent.c"
  46 #endif
  47
  48 #include "glib-private.h" /* g_dir_open_with_errno, g_dir_new_from_dirp */
  49
  50 /**
  51  * GDir:
  52  *
  53  * An opaque structure representing an opened directory.
  54  */
  55
  56 struct _GDir
  57 {
  58 #ifdef G_OS_WIN32
  59   _WDIR *wdirp;
  60 #else
  61   DIR *dirp;
  62 #endif
  63 #ifdef G_OS_WIN32
  64   gchar utf8_buf[FILENAME_MAX*4];
  65 #endif
  66 };
  67
  68 /*< private >
  69  * g_dir_open_with_errno:
  70  * @path: the path to the directory you are interested in.
  71  * @flags: Currently must be set to 0. Reserved for future use.
  72  *
  73  * Opens a directory for reading.
  74  *
  75  * This function is equivalent to g_dir_open() except in the error case,
  76  * errno will be set accordingly.
  77  *
  78  * This is useful if you want to construct your own error message.
  79  *
  80  * Returns: a newly allocated #GDir on success, or %NULL on failure,
  81  *   with errno set accordingly.
  82  *
  83  * Since: 2.38
  84  */
  85 GDir *
  86 g_dir_open_with_errno (const gchar *path,
  87                        guint        flags)
  88 {
  89   GDir dir;
  90 #ifdef G_OS_WIN32
  91   gint saved_errno;
  92   wchar_t *wpath;
  93 #endif
  94
  95   g_return_val_if_fail (path != NULL, NULL);
  96
  97 #ifdef G_OS_WIN32
  98   wpath = g_utf8_to_utf16 (path, -1, NULL, NULL, NULL);
  99
 100   g_return_val_if_fail (wpath != NULL, NULL);
 101
 102   dir.wdirp = _wopendir (wpath);
 103   saved_errno = errno;
 104   g_free (wpath);
 105   errno = saved_errno;
 106
 107   if (dir.wdirp == NULL)
 108     return NULL;
 109 #else
 110   dir.dirp = opendir (path);
 111
 112   if (dir.dirp == NULL)
 113     return NULL;
 114 #endif
 115
 116   return g_memdup (&dir, sizeof dir);
 117 }
 118
 119 /**
 120  * g_dir_open:
 121  * @path: the path to the directory you are interested in. On Unix
 122  *         in the on-disk encoding. On Windows in UTF-8
 123  * @flags: Currently must be set to 0. Reserved for future use.
 124  * @error: return location for a #GError, or %NULL.
 125  *         If non-%NULL, an error will be set if and only if
 126  *         g_dir_open() fails.
 127  *
 128  * Opens a directory for reading. The names of the files in the
 129  * directory can then be retrieved using g_dir_read_name().  Note
 130  * that the ordering is not defined.
 131  *
 132  * Return value: a newly allocated #GDir on success, %NULL on failure.
 133  *   If non-%NULL, you must free the result with g_dir_close()
 134  *   when you are finished with it.
 135  **/
 136 GDir *
 137 g_dir_open (const gchar  *path,
 138             guint         flags,
 139             GError      **error)
 140 {
 141   gint saved_errno;
 142   GDir *dir;
 143
 144   dir = g_dir_open_with_errno (path, flags);
 145
 146   if (dir == NULL)
 147     {
 148       gchar *utf8_path;
 149
 150       saved_errno = errno;
 151
 152       utf8_path = g_filename_to_utf8 (path, -1, NULL, NULL, NULL);
 153
 154       g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (saved_errno),
 155                    _("Error opening directory '%s': %s"), utf8_path, g_strerror (saved_errno));
 156       g_free (utf8_path);
 157     }
 158
 159   return dir;
 160 }
 161
 162 #if defined (G_OS_WIN32) && !defined (_WIN64)
 163
 164 /* The above function actually is called g_dir_open_utf8, and it's
 165  * that what applications compiled with this GLib version will
 166  * use.
 167  */
 168
 169 #undef g_dir_open
 170
 171 /* Binary compatibility version. Not for newly compiled code. */
 172
 173 GDir *
 174 g_dir_open (const gchar  *path,
 175             guint         flags,
 176             GError      **error)
 177 {
 178   gchar *utf8_path = g_locale_to_utf8 (path, -1, NULL, NULL, error);
 179   GDir *retval;
 180
 181   if (utf8_path == NULL)
 182     return NULL;
 183
 184   retval = g_dir_open_utf8 (utf8_path, flags, error);
 185
 186   g_free (utf8_path);
 187
 188   return retval;
 189 }
 190 #endif
 191
 192 /*< private >
 193  * g_dir_new_from_dirp:
 194  * @dirp: a #DIR* created by opendir() or fdopendir()
 195  *
 196  * Creates a #GDir object from the DIR object that is created using
 197  * opendir() or fdopendir().  The created #GDir assumes ownership of the
 198  * passed-in #DIR pointer.
 199  *
 200  * @dirp must not be %NULL.
 201  *
 202  * This function never fails.
 203  *
 204  * Returns: a newly allocated #GDir, which should be closed using
 205  *     g_dir_close().
 206  *
 207  * Since: 2.38
 208  **/
 209 GDir *
 210 g_dir_new_from_dirp (gpointer dirp)
 211 {
 212 #ifdef G_OS_UNIX
 213   GDir *dir;
 214
 215   g_return_val_if_fail (dirp != NULL, NULL);
 216
 217   dir = g_new (GDir, 1);
 218   dir->dirp = dirp;
 219
 220   return dir;
 221 #else
 222   g_assert_not_reached ();
 223 #endif
 224 }
 225
 226 /**
 227  * g_dir_read_name:
 228  * @dir: a #GDir* created by g_dir_open()
 229  *
 230  * Retrieves the name of another entry in the directory, or %NULL.
 231  * The order of entries returned from this function is not defined,
 232  * and may vary by file system or other operating-system dependent
 233  * factors.
 234  *
 235  * %NULL may also be returned in case of errors. On Unix, you can
 236  * check <literal>errno</literal> to find out if %NULL was returned
 237  * because of an error.
 238  *
 239  * On Unix, the '.' and '..' entries are omitted, and the returned
 240  * name is in the on-disk encoding.
 241  *
 242  * On Windows, as is true of all GLib functions which operate on
 243  * filenames, the returned name is in UTF-8.
 244  *
 245  * Return value: The entry's name or %NULL if there are no
 246  *   more entries. The return value is owned by GLib and
 247  *   must not be modified or freed.
 248  **/
 249 const gchar *
 250 g_dir_read_name (GDir *dir)
 251 {
 252 #ifdef G_OS_WIN32
 253   gchar *utf8_name;
 254   struct _wdirent *wentry;
 255 #else
 256   struct dirent *entry;
 257 #endif
 258
 259   g_return_val_if_fail (dir != NULL, NULL);
 260
 261 #ifdef G_OS_WIN32
 262   while (1)
 263     {
 264       wentry = _wreaddir (dir->wdirp);
 265       while (wentry
 266              && (0 == wcscmp (wentry->d_name, L".") ||
 267                  0 == wcscmp (wentry->d_name, L"..")))
 268         wentry = _wreaddir (dir->wdirp);
 269
 270       if (wentry == NULL)
 271         return NULL;
 272
 273       utf8_name = g_utf16_to_utf8 (wentry->d_name, -1, NULL, NULL, NULL);
 274
 275       if (utf8_name == NULL)
 276         continue;               /* Huh, impossible? Skip it anyway */
 277
 278       strcpy (dir->utf8_buf, utf8_name);
 279       g_free (utf8_name);
 280
 281       return dir->utf8_buf;
 282     }
 283 #else
 284   entry = readdir (dir->dirp);
 285   while (entry
 286          && (0 == strcmp (entry->d_name, ".") ||
 287              0 == strcmp (entry->d_name, "..")))
 288     entry = readdir (dir->dirp);
 289
 290   if (entry)
 291     return entry->d_name;
 292   else
 293     return NULL;
 294 #endif
 295 }
 296
 297 #if defined (G_OS_WIN32) && !defined (_WIN64)
 298
 299 /* Ditto for g_dir_read_name */
 300
 301 #undef g_dir_read_name
 302
 303 /* Binary compatibility version. Not for newly compiled code. */
 304
 305 const gchar *
 306 g_dir_read_name (GDir *dir)
 307 {
 308   while (1)
 309     {
 310       const gchar *utf8_name = g_dir_read_name_utf8 (dir);
 311       gchar *retval;
 312
 313       if (utf8_name == NULL)
 314         return NULL;
 315
 316       retval = g_locale_from_utf8 (utf8_name, -1, NULL, NULL, NULL);
 317
 318       if (retval != NULL)
 319         {
 320           strcpy (dir->utf8_buf, retval);
 321           g_free (retval);
 322
 323           return dir->utf8_buf;
 324         }
 325     }
 326 }
 327
 328 #endif
 329
 330 /**
 331  * g_dir_rewind:
 332  * @dir: a #GDir* created by g_dir_open()
 333  *
 334  * Resets the given directory. The next call to g_dir_read_name()
 335  * will return the first entry again.
 336  **/
 337 void
 338 g_dir_rewind (GDir *dir)
 339 {
 340   g_return_if_fail (dir != NULL);
 341
 342 #ifdef G_OS_WIN32
 343   _wrewinddir (dir->wdirp);
 344 #else
 345   rewinddir (dir->dirp);
 346 #endif
 347 }
 348
 349 /**
 350  * g_dir_close:
 351  * @dir: a #GDir* created by g_dir_open()
 352  *
 353  * Closes the directory and deallocates all related resources.
 354  **/
 355 void
 356 g_dir_close (GDir *dir)
 357 {
 358   g_return_if_fail (dir != NULL);
 359
 360 #ifdef G_OS_WIN32
 361   _wclosedir (dir->wdirp);
 362 #else
 363   closedir (dir->dirp);
 364 #endif
 365   g_free (dir);
 366 }