| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2006-2007 Red Hat, Inc. |
| * |
| * SPDX-License-Identifier: LGPL-2.1-or-later |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| * Author: Alexander Larsson <alexl@redhat.com> |
| */ |
| |
| #include "config.h" |
| |
| #include <glib.h> |
| #include <gcancellable.h> |
| #include <glocalfileenumerator.h> |
| #include <glocalfileinfo.h> |
| #include <glocalfile.h> |
| #include <gioerror.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include "glibintl.h" |
| |
| |
| #define CHUNK_SIZE 1000 |
| |
| #ifdef G_OS_WIN32 |
| #define USE_GDIR |
| #endif |
| |
| #ifndef USE_GDIR |
| |
| #include <sys/types.h> |
| #include <dirent.h> |
| #include <errno.h> |
| |
| typedef struct { |
| char *name; |
| long inode; |
| GFileType type; |
| } DirEntry; |
| |
| #endif |
| |
| struct _GLocalFileEnumerator |
| { |
| GFileEnumerator parent; |
| |
| GFileAttributeMatcher *matcher; |
| GFileAttributeMatcher *reduced_matcher; |
| char *filename; |
| char *attributes; |
| GFileQueryInfoFlags flags; |
| |
| gboolean got_parent_info; |
| GLocalParentFileInfo parent_info; |
| |
| #ifdef USE_GDIR |
| GDir *dir; |
| #else |
| DIR *dir; |
| DirEntry *entries; |
| int entries_pos; |
| gboolean at_end; |
| #endif |
| |
| gboolean follow_symlinks; |
| }; |
| |
| #define g_local_file_enumerator_get_type _g_local_file_enumerator_get_type |
| G_DEFINE_TYPE (GLocalFileEnumerator, g_local_file_enumerator, G_TYPE_FILE_ENUMERATOR) |
| |
| static GFileInfo *g_local_file_enumerator_next_file (GFileEnumerator *enumerator, |
| GCancellable *cancellable, |
| GError **error); |
| static gboolean g_local_file_enumerator_close (GFileEnumerator *enumerator, |
| GCancellable *cancellable, |
| GError **error); |
| |
| |
| static void |
| free_entries (GLocalFileEnumerator *local) |
| { |
| #ifndef USE_GDIR |
| int i; |
| |
| if (local->entries != NULL) |
| { |
| for (i = 0; local->entries[i].name != NULL; i++) |
| g_free (local->entries[i].name); |
| |
| g_free (local->entries); |
| } |
| #endif |
| } |
| |
| static void |
| g_local_file_enumerator_finalize (GObject *object) |
| { |
| GLocalFileEnumerator *local; |
| |
| local = G_LOCAL_FILE_ENUMERATOR (object); |
| |
| if (local->got_parent_info) |
| _g_local_file_info_free_parent_info (&local->parent_info); |
| g_free (local->filename); |
| g_file_attribute_matcher_unref (local->matcher); |
| g_file_attribute_matcher_unref (local->reduced_matcher); |
| if (local->dir) |
| { |
| #ifdef USE_GDIR |
| g_dir_close (local->dir); |
| #else |
| closedir (local->dir); |
| #endif |
| local->dir = NULL; |
| } |
| |
| free_entries (local); |
| |
| G_OBJECT_CLASS (g_local_file_enumerator_parent_class)->finalize (object); |
| } |
| |
| |
| static void |
| g_local_file_enumerator_class_init (GLocalFileEnumeratorClass *klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| GFileEnumeratorClass *enumerator_class = G_FILE_ENUMERATOR_CLASS (klass); |
| |
| gobject_class->finalize = g_local_file_enumerator_finalize; |
| |
| enumerator_class->next_file = g_local_file_enumerator_next_file; |
| enumerator_class->close_fn = g_local_file_enumerator_close; |
| } |
| |
| static void |
| g_local_file_enumerator_init (GLocalFileEnumerator *local) |
| { |
| } |
| |
| #ifdef USE_GDIR |
| static void |
| convert_file_to_io_error (GError **error, |
| GError *file_error) |
| { |
| int new_code; |
| |
| if (file_error == NULL) |
| return; |
| |
| new_code = G_IO_ERROR_FAILED; |
| |
| if (file_error->domain == G_FILE_ERROR) |
| { |
| switch (file_error->code) |
| { |
| case G_FILE_ERROR_NOENT: |
| new_code = G_IO_ERROR_NOT_FOUND; |
| break; |
| case G_FILE_ERROR_ACCES: |
| new_code = G_IO_ERROR_PERMISSION_DENIED; |
| break; |
| case G_FILE_ERROR_NOTDIR: |
| new_code = G_IO_ERROR_NOT_DIRECTORY; |
| break; |
| case G_FILE_ERROR_MFILE: |
| new_code = G_IO_ERROR_TOO_MANY_OPEN_FILES; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| g_set_error_literal (error, G_IO_ERROR, |
| new_code, |
| file_error->message); |
| } |
| #else |
| static GFileAttributeMatcher * |
| g_file_attribute_matcher_subtract_attributes (GFileAttributeMatcher *matcher, |
| const char * attributes) |
| { |
| GFileAttributeMatcher *result, *tmp; |
| |
| tmp = g_file_attribute_matcher_new (attributes); |
| result = g_file_attribute_matcher_subtract (matcher, tmp); |
| g_file_attribute_matcher_unref (tmp); |
| |
| return result; |
| } |
| #endif |
| |
| GFileEnumerator * |
| _g_local_file_enumerator_new (GLocalFile *file, |
| const char *attributes, |
| GFileQueryInfoFlags flags, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GLocalFileEnumerator *local; |
| char *filename = g_file_get_path (G_FILE (file)); |
| |
| #ifdef USE_GDIR |
| GError *dir_error; |
| GDir *dir; |
| |
| dir_error = NULL; |
| dir = g_dir_open (filename, 0, error != NULL ? &dir_error : NULL); |
| if (dir == NULL) |
| { |
| if (error != NULL) |
| { |
| convert_file_to_io_error (error, dir_error); |
| g_error_free (dir_error); |
| } |
| g_free (filename); |
| return NULL; |
| } |
| #else |
| DIR *dir; |
| int errsv; |
| |
| dir = opendir (filename); |
| if (dir == NULL) |
| { |
| gchar *utf8_filename; |
| errsv = errno; |
| |
| utf8_filename = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL); |
| g_set_error (error, G_IO_ERROR, |
| g_io_error_from_errno (errsv), |
| "Error opening directory '%s': %s", |
| utf8_filename, g_strerror (errsv)); |
| g_free (utf8_filename); |
| g_free (filename); |
| return NULL; |
| } |
| |
| #endif |
| |
| local = g_object_new (G_TYPE_LOCAL_FILE_ENUMERATOR, |
| "container", file, |
| NULL); |
| |
| local->dir = dir; |
| local->filename = filename; |
| local->matcher = g_file_attribute_matcher_new (attributes); |
| #ifndef USE_GDIR |
| local->reduced_matcher = g_file_attribute_matcher_subtract_attributes (local->matcher, |
| G_LOCAL_FILE_INFO_NOSTAT_ATTRIBUTES"," |
| "standard::type"); |
| #endif |
| local->flags = flags; |
| |
| return G_FILE_ENUMERATOR (local); |
| } |
| |
| #ifndef USE_GDIR |
| static int |
| sort_by_inode (const void *_a, const void *_b) |
| { |
| const DirEntry *a, *b; |
| |
| a = _a; |
| b = _b; |
| return a->inode - b->inode; |
| } |
| |
| #ifdef HAVE_STRUCT_DIRENT_D_TYPE |
| static GFileType |
| file_type_from_dirent (char d_type) |
| { |
| switch (d_type) |
| { |
| case DT_BLK: |
| case DT_CHR: |
| case DT_FIFO: |
| case DT_SOCK: |
| return G_FILE_TYPE_SPECIAL; |
| case DT_DIR: |
| return G_FILE_TYPE_DIRECTORY; |
| case DT_LNK: |
| return G_FILE_TYPE_SYMBOLIC_LINK; |
| case DT_REG: |
| return G_FILE_TYPE_REGULAR; |
| case DT_UNKNOWN: |
| default: |
| return G_FILE_TYPE_UNKNOWN; |
| } |
| } |
| #endif |
| |
| static const char * |
| next_file_helper (GLocalFileEnumerator *local, GFileType *file_type) |
| { |
| struct dirent *entry; |
| const char *filename; |
| int i; |
| |
| if (local->at_end) |
| return NULL; |
| |
| if (local->entries == NULL || |
| (local->entries[local->entries_pos].name == NULL)) |
| { |
| if (local->entries == NULL) |
| local->entries = g_new (DirEntry, CHUNK_SIZE + 1); |
| else |
| { |
| /* Restart by clearing old names */ |
| for (i = 0; local->entries[i].name != NULL; i++) |
| g_free (local->entries[i].name); |
| } |
| |
| for (i = 0; i < CHUNK_SIZE; i++) |
| { |
| entry = readdir (local->dir); |
| while (entry |
| && (0 == strcmp (entry->d_name, ".") || |
| 0 == strcmp (entry->d_name, ".."))) |
| entry = readdir (local->dir); |
| |
| if (entry) |
| { |
| local->entries[i].name = g_strdup (entry->d_name); |
| local->entries[i].inode = entry->d_ino; |
| #if HAVE_STRUCT_DIRENT_D_TYPE |
| local->entries[i].type = file_type_from_dirent (entry->d_type); |
| #else |
| local->entries[i].type = G_FILE_TYPE_UNKNOWN; |
| #endif |
| } |
| else |
| break; |
| } |
| local->entries[i].name = NULL; |
| local->entries_pos = 0; |
| |
| qsort (local->entries, i, sizeof (DirEntry), sort_by_inode); |
| } |
| |
| filename = local->entries[local->entries_pos].name; |
| if (filename == NULL) |
| local->at_end = TRUE; |
| |
| *file_type = local->entries[local->entries_pos].type; |
| |
| local->entries_pos++; |
| |
| return filename; |
| } |
| |
| #endif |
| |
| static GFileInfo * |
| g_local_file_enumerator_next_file (GFileEnumerator *enumerator, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GLocalFileEnumerator *local = G_LOCAL_FILE_ENUMERATOR (enumerator); |
| const char *filename; |
| char *path; |
| GFileInfo *info; |
| GError *my_error; |
| GFileType file_type; |
| |
| if (!local->got_parent_info) |
| { |
| _g_local_file_info_get_parent_info (local->filename, local->matcher, &local->parent_info); |
| local->got_parent_info = TRUE; |
| } |
| |
| next_file: |
| |
| if (g_cancellable_set_error_if_cancelled (cancellable, error)) |
| return NULL; |
| |
| #ifdef USE_GDIR |
| filename = g_dir_read_name (local->dir); |
| file_type = G_FILE_TYPE_UNKNOWN; |
| #else |
| filename = next_file_helper (local, &file_type); |
| #endif |
| |
| if (filename == NULL) |
| return NULL; |
| |
| my_error = NULL; |
| path = g_build_filename (local->filename, filename, NULL); |
| if (file_type == G_FILE_TYPE_UNKNOWN || |
| (file_type == G_FILE_TYPE_SYMBOLIC_LINK && !(local->flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS))) |
| { |
| info = _g_local_file_info_get (filename, path, |
| local->matcher, |
| local->flags, |
| &local->parent_info, |
| &my_error); |
| } |
| else |
| { |
| info = _g_local_file_info_get (filename, path, |
| local->reduced_matcher, |
| local->flags, |
| &local->parent_info, |
| &my_error); |
| if (info) |
| { |
| _g_local_file_info_get_nostat (info, filename, path, local->matcher); |
| g_file_info_set_file_type (info, file_type); |
| if (file_type == G_FILE_TYPE_SYMBOLIC_LINK) |
| g_file_info_set_is_symlink (info, TRUE); |
| } |
| } |
| g_free (path); |
| |
| if (info == NULL) |
| { |
| /* Failed to get info */ |
| /* If the file does not exist there might have been a race where |
| * the file was removed between the readdir and the stat, so we |
| * ignore the file. */ |
| if (g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) |
| { |
| g_error_free (my_error); |
| goto next_file; |
| } |
| else |
| g_propagate_error (error, my_error); |
| } |
| |
| return info; |
| } |
| |
| static gboolean |
| g_local_file_enumerator_close (GFileEnumerator *enumerator, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GLocalFileEnumerator *local = G_LOCAL_FILE_ENUMERATOR (enumerator); |
| |
| if (local->dir) |
| { |
| #ifdef USE_GDIR |
| g_dir_close (local->dir); |
| #else |
| closedir (local->dir); |
| #endif |
| local->dir = NULL; |
| } |
| |
| return TRUE; |
| } |