mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-10 03:16:17 +01:00
5942cd7984
Add SPDX license (but not copyright) headers to all files which follow a certain pattern in their existing non-machine-readable header comment. This commit was entirely generated using the command: ``` git ls-files gio/*.[ch] | xargs perl -0777 -pi -e 's/\n \*\n \* This library is free software; you can redistribute it and\/or\n \* modify it under the terms of the GNU Lesser General Public/\n \*\n \* SPDX-License-Identifier: LGPL-2.1-or-later\n \*\n \* This library is free software; you can redistribute it and\/or\n \* modify it under the terms of the GNU Lesser General Public/igs' ``` Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1415
461 lines
11 KiB
C
461 lines
11 KiB
C
/* 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 <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:
|
|
|
|
#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;
|
|
}
|