luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-25 23:16:14 +01:00
Code Issues Packages Projects Releases Wiki Activity
6e4a7fca43
glib/gio/glocalfileinfo.c
Ryan Lortie fe7069749f file-info: Add a G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID attribute 
This indicates whether the thumbnail (given by G_FILE_ATTRIBUTE_THUMBNAIL_PATH)
is valid — i.e. to represent the file in its current state. If
G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID is FALSE (for a normal _or_ failed
thumbnail) it means the file has changed since the thumbnail was generated, and
the thumbnail is out of date.

Part of checking thumbnail validity (by the spec) involves parsing
headers out of the thumbnail .png so we include some (small) code to do
that in a separate file.  We will likely want to copy this code to gvfs
to do the same for GVfsFile.

Heavily based on a patch from Philip Withnall <philip.withnall@collabora.co.uk>
who suggested the feature and designed the API.

https://bugzilla.gnome.org/show_bug.cgi?id=709898
2013-10-23 11:56:28 -04:00

2671 lines
69 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2006-2007 Red Hat, Inc.
*
* 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 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, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#include "config.h"
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fcntl.h>
#include <errno.h>
#ifdef HAVE_GRP_H
#include <grp.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_SELINUX
#include <selinux/selinux.h>
#endif
#ifdef HAVE_XATTR
#if defined HAVE_SYS_XATTR_H
#include <sys/xattr.h>
#elif defined HAVE_ATTR_XATTR_H
#include <attr/xattr.h>
#else
#error "Neither <sys/xattr.h> nor <attr/xattr.h> is present but extended attribute support is enabled."
#endif /* defined HAVE_SYS_XATTR_H || HAVE_ATTR_XATTR_H */
#endif /* HAVE_XATTR */
#include <glib/gstdio.h>
#include <gfileattribute-priv.h>
#include <gfileinfo-priv.h>
#include <gvfs.h>
#ifndef G_OS_WIN32
#include "glib-unix.h"
#include "glib-private.h"
#endif
#include "glibintl.h"
#include "thumbnail-verify.h"
#ifdef G_OS_WIN32
#include <windows.h>
#include <io.h>
#ifndef W_OK
#define W_OK 2
#endif
#ifndef R_OK
#define R_OK 4
#endif
#ifndef X_OK
#define X_OK 0 /* not really */
#endif
#ifndef S_ISREG
#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
#endif
#ifndef S_ISDIR
#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
#endif
#ifndef S_IXUSR
#define S_IXUSR _S_IEXEC
#endif
#endif
#include "glocalfileinfo.h"
#include "gioerror.h"
#include "gthemedicon.h"
#include "gcontenttypeprivate.h"
struct ThumbMD5Context {
guint32 buf[4];
guint32 bits[2];
unsigned char in[64];
};
#ifndef G_OS_WIN32
typedef struct {
char *user_name;
char *real_name;
} UidData;
G_LOCK_DEFINE_STATIC (uid_cache);
static GHashTable *uid_cache = NULL;
G_LOCK_DEFINE_STATIC (gid_cache);
static GHashTable *gid_cache = NULL;
#endif /* !G_OS_WIN32 */
char *
_g_local_file_info_create_etag (GLocalFileStat *statbuf)
{
glong sec, usec;
sec = statbuf->st_mtime;
#if defined (HAVE_STRUCT_STAT_ST_MTIMENSEC)
usec = statbuf->st_mtimensec / 1000;
#elif defined (HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
usec = statbuf->st_mtim.tv_nsec / 1000;
#else
usec = 0;
#endif
return g_strdup_printf ("%lu:%lu", sec, usec);
}
static char *
_g_local_file_info_create_file_id (GLocalFileStat *statbuf)
{
return g_strdup_printf ("l%" G_GUINT64_FORMAT ":%" G_GUINT64_FORMAT,
(guint64) statbuf->st_dev,
(guint64) statbuf->st_ino);
}
static char *
_g_local_file_info_create_fs_id (GLocalFileStat *statbuf)
{
return g_strdup_printf ("l%" G_GUINT64_FORMAT,
(guint64) statbuf->st_dev);
}
#ifdef S_ISLNK
static gchar *
read_link (const gchar *full_name)
{
#ifdef HAVE_READLINK
gchar *buffer;
guint size;
size = 256;
buffer = g_malloc (size);
while (1)
{
int read_size;
read_size = readlink (full_name, buffer, size);
if (read_size < 0)
{
g_free (buffer);
return NULL;
}
if (read_size < size)
{
buffer[read_size] = 0;
return buffer;
}
size *= 2;
buffer = g_realloc (buffer, size);
}
#else
return NULL;
#endif
}
#endif /* S_ISLNK */
#ifdef HAVE_SELINUX
/* Get the SELinux security context */
static void
get_selinux_context (const char *path,
GFileInfo *info,
GFileAttributeMatcher *attribute_matcher,
gboolean follow_symlinks)
{
char *context;
if (!_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT))
return;
if (is_selinux_enabled ())
{
if (follow_symlinks)
{
if (lgetfilecon_raw (path, &context) < 0)
return;
}
else
{
if (getfilecon_raw (path, &context) < 0)
return;
}
if (context)
{
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT, context);
freecon (context);
}
}
}
#endif
#ifdef HAVE_XATTR
/* Wrappers to hide away differences between (Linux) getxattr/lgetxattr and
* (Mac) getxattr(..., XATTR_NOFOLLOW)
*/
#ifdef HAVE_XATTR_NOFOLLOW
#define g_fgetxattr(fd,name,value,size) fgetxattr(fd,name,value,size,0,0)
#define g_flistxattr(fd,name,size) flistxattr(fd,name,size,0)
#define g_setxattr(path,name,value,size) setxattr(path,name,value,size,0,0)
#else
#define g_fgetxattr fgetxattr
#define g_flistxattr flistxattr
#define g_setxattr(path,name,value,size) setxattr(path,name,value,size,0)
#endif
static ssize_t
g_getxattr (const char *path, const char *name, void *value, size_t size,
gboolean follow_symlinks)
{
#ifdef HAVE_XATTR_NOFOLLOW
return getxattr (path, name, value, size, 0, follow_symlinks ? 0 : XATTR_NOFOLLOW);
#else
if (follow_symlinks)
return getxattr (path, name, value, size);
else
return lgetxattr (path, name, value, size);
#endif
}
static ssize_t
g_listxattr(const char *path, char *namebuf, size_t size,
gboolean follow_symlinks)
{
#ifdef HAVE_XATTR_NOFOLLOW
return listxattr (path, namebuf, size, follow_symlinks ? 0 : XATTR_NOFOLLOW);
#else
if (follow_symlinks)
return listxattr (path, namebuf, size);
else
return llistxattr (path, namebuf, size);
#endif
}
static gboolean
valid_char (char c)
{
return c >= 32 && c <= 126 && c != '\\';
}
static gboolean
name_is_valid (const char *str)
{
while (*str)
{
if (!valid_char (*str++))
return FALSE;
}
return TRUE;
}
static char *
hex_escape_string (const char *str,
gboolean *free_return)
{
int num_invalid, i;
char *escaped_str, *p;
unsigned char c;
static char *hex_digits = "0123456789abcdef";
int len;
len = strlen (str);
num_invalid = 0;
for (i = 0; i < len; i++)
{
if (!valid_char (str[i]))
num_invalid++;
}
if (num_invalid == 0)
{
*free_return = FALSE;
return (char *)str;
}
escaped_str = g_malloc (len + num_invalid*3 + 1);
p = escaped_str;
for (i = 0; i < len; i++)
{
if (valid_char (str[i]))
*p++ = str[i];
else
{
c = str[i];
*p++ = '\\';
*p++ = 'x';
*p++ = hex_digits[(c >> 4) & 0xf];
*p++ = hex_digits[c & 0xf];
}
}
*p = 0;
*free_return = TRUE;
return escaped_str;
}
static char *
hex_unescape_string (const char *str,
int *out_len,
gboolean *free_return)
{
int i;
char *unescaped_str, *p;
unsigned char c;
int len;
len = strlen (str);
if (strchr (str, '\\') == NULL)
{
if (out_len)
*out_len = len;
*free_return = FALSE;
return (char *)str;
}
unescaped_str = g_malloc (len + 1);
p = unescaped_str;
for (i = 0; i < len; i++)
{
if (str[i] == '\\' &&
str[i+1] == 'x' &&
len - i >= 4)
{
c =
(g_ascii_xdigit_value (str[i+2]) << 4) |
g_ascii_xdigit_value (str[i+3]);
*p++ = c;
i += 3;
}
else
*p++ = str[i];
}
*p++ = 0;
if (out_len)
*out_len = p - unescaped_str;
*free_return = TRUE;
return unescaped_str;
}
static void
escape_xattr (GFileInfo *info,
const char *gio_attr, /* gio attribute name */
const char *value, /* Is zero terminated */
size_t len /* not including zero termination */)
{
char *escaped_val;
gboolean free_escaped_val;
escaped_val = hex_escape_string (value, &free_escaped_val);
g_file_info_set_attribute_string (info, gio_attr, escaped_val);
if (free_escaped_val)
g_free (escaped_val);
}
static void
get_one_xattr (const char *path,
GFileInfo *info,
const char *gio_attr,
const char *xattr,
gboolean follow_symlinks)
{
char value[64];
char *value_p;
ssize_t len;
len = g_getxattr (path, xattr, value, sizeof (value)-1, follow_symlinks);
value_p = NULL;
if (len >= 0)
value_p = value;
else if (len == -1 && errno == ERANGE)
{
len = g_getxattr (path, xattr, NULL, 0, follow_symlinks);
if (len < 0)
return;
value_p = g_malloc (len+1);
len = g_getxattr (path, xattr, value_p, len, follow_symlinks);
if (len < 0)
{
g_free (value_p);
return;
}
}
else
return;
/* Null terminate */
value_p[len] = 0;
escape_xattr (info, gio_attr, value_p, len);
if (value_p != value)
g_free (value_p);
}
#endif /* defined HAVE_XATTR */
static void
get_xattrs (const char *path,
gboolean user,
GFileInfo *info,
GFileAttributeMatcher *matcher,
gboolean follow_symlinks)
{
#ifdef HAVE_XATTR
gboolean all;
gsize list_size;
ssize_t list_res_size;
size_t len;
char *list;
const char *attr, *attr2;
if (user)
all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr");
else
all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr-sys");
if (all)
{
list_res_size = g_listxattr (path, NULL, 0, follow_symlinks);
if (list_res_size == -1 ||
list_res_size == 0)
return;
list_size = list_res_size;
list = g_malloc (list_size);
retry:
list_res_size = g_listxattr (path, list, list_size, follow_symlinks);
if (list_res_size == -1 && errno == ERANGE)
{
list_size = list_size * 2;
list = g_realloc (list, list_size);
goto retry;
}
if (list_res_size == -1)
return;
attr = list;
while (list_res_size > 0)
{
if ((user && g_str_has_prefix (attr, "user.")) ||
(!user && !g_str_has_prefix (attr, "user.")))
{
char *escaped_attr, *gio_attr;
gboolean free_escaped_attr;
if (user)
{
escaped_attr = hex_escape_string (attr + 5, &free_escaped_attr);
gio_attr = g_strconcat ("xattr::", escaped_attr, NULL);
}
else
{
escaped_attr = hex_escape_string (attr, &free_escaped_attr);
gio_attr = g_strconcat ("xattr-sys::", escaped_attr, NULL);
}
if (free_escaped_attr)
g_free (escaped_attr);
get_one_xattr (path, info, gio_attr, attr, follow_symlinks);
g_free (gio_attr);
}
len = strlen (attr) + 1;
attr += len;
list_res_size -= len;
}
g_free (list);
}
else
{
while ((attr = g_file_attribute_matcher_enumerate_next (matcher)) != NULL)
{
char *unescaped_attribute, *a;
gboolean free_unescaped_attribute;
attr2 = strchr (attr, ':');
if (attr2)
{
attr2 += 2; /* Skip '::' */
unescaped_attribute = hex_unescape_string (attr2, NULL, &free_unescaped_attribute);
if (user)
a = g_strconcat ("user.", unescaped_attribute, NULL);
else
a = unescaped_attribute;
get_one_xattr (path, info, attr, a, follow_symlinks);
if (user)
g_free (a);
if (free_unescaped_attribute)
g_free (unescaped_attribute);
}
}
}
#endif /* defined HAVE_XATTR */
}
#ifdef HAVE_XATTR
static void
get_one_xattr_from_fd (int fd,
GFileInfo *info,
const char *gio_attr,
const char *xattr)
{
char value[64];
char *value_p;
ssize_t len;
len = g_fgetxattr (fd, xattr, value, sizeof (value) - 1);
value_p = NULL;
if (len >= 0)
value_p = value;
else if (len == -1 && errno == ERANGE)
{
len = g_fgetxattr (fd, xattr, NULL, 0);
if (len < 0)
return;
value_p = g_malloc (len + 1);
len = g_fgetxattr (fd, xattr, value_p, len);
if (len < 0)
{
g_free (value_p);
return;
}
}
else
return;
/* Null terminate */
value_p[len] = 0;
escape_xattr (info, gio_attr, value_p, len);
if (value_p != value)
g_free (value_p);
}
#endif /* defined HAVE_XATTR */
static void
get_xattrs_from_fd (int fd,
gboolean user,
GFileInfo *info,
GFileAttributeMatcher *matcher)
{
#ifdef HAVE_XATTR
gboolean all;
gsize list_size;
ssize_t list_res_size;
size_t len;
char *list;
const char *attr, *attr2;
if (user)
all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr");
else
all = g_file_attribute_matcher_enumerate_namespace (matcher, "xattr-sys");
if (all)
{
list_res_size = g_flistxattr (fd, NULL, 0);
if (list_res_size == -1 ||
list_res_size == 0)
return;
list_size = list_res_size;
list = g_malloc (list_size);
retry:
list_res_size = g_flistxattr (fd, list, list_size);
if (list_res_size == -1 && errno == ERANGE)
{
list_size = list_size * 2;
list = g_realloc (list, list_size);
goto retry;
}
if (list_res_size == -1)
return;
attr = list;
while (list_res_size > 0)
{
if ((user && g_str_has_prefix (attr, "user.")) ||
(!user && !g_str_has_prefix (attr, "user.")))
{
char *escaped_attr, *gio_attr;
gboolean free_escaped_attr;
if (user)
{
escaped_attr = hex_escape_string (attr + 5, &free_escaped_attr);
gio_attr = g_strconcat ("xattr::", escaped_attr, NULL);
}
else
{
escaped_attr = hex_escape_string (attr, &free_escaped_attr);
gio_attr = g_strconcat ("xattr-sys::", escaped_attr, NULL);
}
if (free_escaped_attr)
g_free (escaped_attr);
get_one_xattr_from_fd (fd, info, gio_attr, attr);
}
len = strlen (attr) + 1;
attr += len;
list_res_size -= len;
}
g_free (list);
}
else
{
while ((attr = g_file_attribute_matcher_enumerate_next (matcher)) != NULL)
{
char *unescaped_attribute, *a;
gboolean free_unescaped_attribute;
attr2 = strchr (attr, ':');
if (attr2)
{
attr2++; /* Skip ':' */
unescaped_attribute = hex_unescape_string (attr2, NULL, &free_unescaped_attribute);
if (user)
a = g_strconcat ("user.", unescaped_attribute, NULL);
else
a = unescaped_attribute;
get_one_xattr_from_fd (fd, info, attr, a);
if (user)
g_free (a);
if (free_unescaped_attribute)
g_free (unescaped_attribute);
}
}
}
#endif /* defined HAVE_XATTR */
}
#ifdef HAVE_XATTR
static gboolean
set_xattr (char *filename,
const char *escaped_attribute,
const GFileAttributeValue *attr_value,
GError **error)
{
char *attribute, *value;
gboolean free_attribute, free_value;
int val_len, res, errsv;
gboolean is_user;
char *a;
if (attr_value == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Attribute value must be non-NULL"));
return FALSE;
}
if (attr_value->type != G_FILE_ATTRIBUTE_TYPE_STRING)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid attribute type (string expected)"));
return FALSE;
}
if (!name_is_valid (escaped_attribute))
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid extended attribute name"));
return FALSE;
}
if (g_str_has_prefix (escaped_attribute, "xattr::"))
{
escaped_attribute += strlen ("xattr::");
is_user = TRUE;
}
else
{
g_warn_if_fail (g_str_has_prefix (escaped_attribute, "xattr-sys::"));
escaped_attribute += strlen ("xattr-sys::");
is_user = FALSE;
}
attribute = hex_unescape_string (escaped_attribute, NULL, &free_attribute);
value = hex_unescape_string (attr_value->u.string, &val_len, &free_value);
if (is_user)
a = g_strconcat ("user.", attribute, NULL);
else
a = attribute;
res = g_setxattr (filename, a, value, val_len);
errsv = errno;
if (is_user)
g_free (a);
if (free_attribute)
g_free (attribute);
if (free_value)
g_free (value);
if (res == -1)
{
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting extended attribute '%s': %s"),
escaped_attribute, g_strerror (errsv));
return FALSE;
}
return TRUE;
}
#endif
void
_g_local_file_info_get_parent_info (const char *dir,
GFileAttributeMatcher *attribute_matcher,
GLocalParentFileInfo *parent_info)
{
GStatBuf statbuf;
int res;
parent_info->extra_data = NULL;
parent_info->free_extra_data = NULL;
parent_info->writable = FALSE;
parent_info->is_sticky = FALSE;
parent_info->has_trash_dir = FALSE;
parent_info->device = 0;
if (_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME) ||
_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE) ||
_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH) ||
_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_UNIX_IS_MOUNTPOINT))
{
/* FIXME: Windows: The underlying _waccess() call in the C
* library is mostly pointless as it only looks at the READONLY
* FAT-style attribute of the file, it doesn't check the ACL at
* all.
*/
parent_info->writable = (g_access (dir, W_OK) == 0);
res = g_stat (dir, &statbuf);
/*
* The sticky bit (S_ISVTX) on a directory means that a file in that directory can be
* renamed or deleted only by the owner of the file, by the owner of the directory, and
* by a privileged process.
*/
if (res == 0)
{
#ifdef S_ISVTX
parent_info->is_sticky = (statbuf.st_mode & S_ISVTX) != 0;
#else
parent_info->is_sticky = FALSE;
#endif
parent_info->owner = statbuf.st_uid;
parent_info->device = statbuf.st_dev;
/* No need to find trash dir if it's not writable anyway */
if (parent_info->writable &&
_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH))
parent_info->has_trash_dir = _g_local_file_has_trash_dir (dir, statbuf.st_dev);
}
}
}
void
_g_local_file_info_free_parent_info (GLocalParentFileInfo *parent_info)
{
if (parent_info->extra_data &&
parent_info->free_extra_data)
parent_info->free_extra_data (parent_info->extra_data);
}
static void
get_access_rights (GFileAttributeMatcher *attribute_matcher,
GFileInfo *info,
const gchar *path,
GLocalFileStat *statbuf,
GLocalParentFileInfo *parent_info)
{
/* FIXME: Windows: The underlyin _waccess() is mostly pointless */
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ,
g_access (path, R_OK) == 0);
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ACCESS_CAN_WRITE))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_WRITE,
g_access (path, W_OK) == 0);
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ACCESS_CAN_EXECUTE))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_EXECUTE,
g_access (path, X_OK) == 0);
if (parent_info)
{
gboolean writable;
writable = FALSE;
if (parent_info->writable)
{
if (parent_info->is_sticky)
{
#ifndef G_OS_WIN32
uid_t uid = geteuid ();
if (uid == statbuf->st_uid ||
uid == parent_info->owner ||
uid == 0)
#endif
writable = TRUE;
}
else
writable = TRUE;
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME,
writable);
if (_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE,
writable);
if (_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH,
writable && parent_info->has_trash_dir);
}
}
static void
set_info_from_stat (GFileInfo *info,
GLocalFileStat *statbuf,
GFileAttributeMatcher *attribute_matcher)
{
GFileType file_type;
file_type = G_FILE_TYPE_UNKNOWN;
if (S_ISREG (statbuf->st_mode))
file_type = G_FILE_TYPE_REGULAR;
else if (S_ISDIR (statbuf->st_mode))
file_type = G_FILE_TYPE_DIRECTORY;
#ifndef G_OS_WIN32
else if (S_ISCHR (statbuf->st_mode) ||
S_ISBLK (statbuf->st_mode) ||
S_ISFIFO (statbuf->st_mode)
#ifdef S_ISSOCK
|| S_ISSOCK (statbuf->st_mode)
#endif
)
file_type = G_FILE_TYPE_SPECIAL;
#endif
#ifdef S_ISLNK
else if (S_ISLNK (statbuf->st_mode))
file_type = G_FILE_TYPE_SYMBOLIC_LINK;
#endif
g_file_info_set_file_type (info, file_type);
g_file_info_set_size (info, statbuf->st_size);
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_DEVICE, statbuf->st_dev);
#ifndef G_OS_WIN32
/* Pointless setting these on Windows even if they exist in the struct */
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_INODE, statbuf->st_ino);
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_NLINK, statbuf->st_nlink);
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_UID, statbuf->st_uid);
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_GID, statbuf->st_gid);
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_RDEV, statbuf->st_rdev);
#endif
/* FIXME: st_mode is mostly pointless on Windows, too. Set the attribute or not? */
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_MODE, statbuf->st_mode);
#if defined (HAVE_STRUCT_STAT_ST_BLKSIZE)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_BLOCK_SIZE, statbuf->st_blksize);
#endif
#if defined (HAVE_STRUCT_STAT_ST_BLOCKS)
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_BLOCKS, statbuf->st_blocks);
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_ALLOCATED_SIZE,
statbuf->st_blocks * G_GUINT64_CONSTANT (512));
#endif
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_MODIFIED, statbuf->st_mtime);
#if defined (HAVE_STRUCT_STAT_ST_MTIMENSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_MODIFIED_USEC, statbuf->st_mtimensec / 1000);
#elif defined (HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_MODIFIED_USEC, statbuf->st_mtim.tv_nsec / 1000);
#endif
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_ACCESS, statbuf->st_atime);
#if defined (HAVE_STRUCT_STAT_ST_ATIMENSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_ACCESS_USEC, statbuf->st_atimensec / 1000);
#elif defined (HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_ACCESS_USEC, statbuf->st_atim.tv_nsec / 1000);
#endif
_g_file_info_set_attribute_uint64_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_CHANGED, statbuf->st_ctime);
#if defined (HAVE_STRUCT_STAT_ST_CTIMENSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_CHANGED_USEC, statbuf->st_ctimensec / 1000);
#elif defined (HAVE_STRUCT_STAT_ST_CTIM_TV_NSEC)
_g_file_info_set_attribute_uint32_by_id (info, G_FILE_ATTRIBUTE_ID_TIME_CHANGED_USEC, statbuf->st_ctim.tv_nsec / 1000);
#endif
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ETAG_VALUE))
{
char *etag = _g_local_file_info_create_etag (statbuf);
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_ETAG_VALUE, etag);
g_free (etag);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ID_FILE))
{
char *id = _g_local_file_info_create_file_id (statbuf);
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_ID_FILE, id);
g_free (id);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_ID_FILESYSTEM))
{
char *id = _g_local_file_info_create_fs_id (statbuf);
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_ID_FILESYSTEM, id);
g_free (id);
}
}
#ifndef G_OS_WIN32
static char *
make_valid_utf8 (const char *name)
{
GString *string;
const gchar *remainder, *invalid;
gint remaining_bytes, valid_bytes;
string = NULL;
remainder = name;
remaining_bytes = strlen (name);
while (remaining_bytes != 0)
{
if (g_utf8_validate (remainder, remaining_bytes, &invalid))
break;
valid_bytes = invalid - remainder;
if (string == NULL)
string = g_string_sized_new (remaining_bytes);
g_string_append_len (string, remainder, valid_bytes);
/* append U+FFFD REPLACEMENT CHARACTER */
g_string_append (string, "\357\277\275");
remaining_bytes -= valid_bytes + 1;
remainder = invalid + 1;
}
if (string == NULL)
return g_strdup (name);
g_string_append (string, remainder);
g_warn_if_fail (g_utf8_validate (string->str, -1, NULL));
return g_string_free (string, FALSE);
}
static char *
convert_pwd_string_to_utf8 (char *pwd_str)
{
char *utf8_string;
if (!g_utf8_validate (pwd_str, -1, NULL))
{
utf8_string = g_locale_to_utf8 (pwd_str, -1, NULL, NULL, NULL);
if (utf8_string == NULL)
utf8_string = make_valid_utf8 (pwd_str);
}
else
utf8_string = g_strdup (pwd_str);
return utf8_string;
}
static void
uid_data_free (UidData *data)
{
g_free (data->user_name);
g_free (data->real_name);
g_free (data);
}
/* called with lock held */
static UidData *
lookup_uid_data (uid_t uid)
{
UidData *data;
char buffer[4096];
struct passwd pwbuf;
struct passwd *pwbufp;
char *gecos, *comma;
if (uid_cache == NULL)
uid_cache = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify)uid_data_free);
data = g_hash_table_lookup (uid_cache, GINT_TO_POINTER (uid));
if (data)
return data;
data = g_new0 (UidData, 1);
#if defined(HAVE_POSIX_GETPWUID_R)
getpwuid_r (uid, &pwbuf, buffer, sizeof(buffer), &pwbufp);
#elif defined(HAVE_NONPOSIX_GETPWUID_R)
pwbufp = getpwuid_r (uid, &pwbuf, buffer, sizeof(buffer));
#else
pwbufp = getpwuid (uid);
#endif
if (pwbufp != NULL)
{
if (pwbufp->pw_name != NULL && pwbufp->pw_name[0] != 0)
data->user_name = convert_pwd_string_to_utf8 (pwbufp->pw_name);
#ifndef __BIONIC__
gecos = pwbufp->pw_gecos;
if (gecos)
{
comma = strchr (gecos, ',');
if (comma)
*comma = 0;
data->real_name = convert_pwd_string_to_utf8 (gecos);
}
#endif
}
/* Default fallbacks */
if (data->real_name == NULL)
{
if (data->user_name != NULL)
data->real_name = g_strdup (data->user_name);
else
data->real_name = g_strdup_printf ("user #%d", (int)uid);
}
if (data->user_name == NULL)
data->user_name = g_strdup_printf ("%d", (int)uid);
g_hash_table_replace (uid_cache, GINT_TO_POINTER (uid), data);
return data;
}
static char *
get_username_from_uid (uid_t uid)
{
char *res;
UidData *data;
G_LOCK (uid_cache);
data = lookup_uid_data (uid);
res = g_strdup (data->user_name);
G_UNLOCK (uid_cache);
return res;
}
static char *
get_realname_from_uid (uid_t uid)
{
char *res;
UidData *data;
G_LOCK (uid_cache);
data = lookup_uid_data (uid);
res = g_strdup (data->real_name);
G_UNLOCK (uid_cache);
return res;
}
/* called with lock held */
static char *
lookup_gid_name (gid_t gid)
{
char *name;
char buffer[4096];
struct group gbuf;
struct group *gbufp;
if (gid_cache == NULL)
gid_cache = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify)g_free);
name = g_hash_table_lookup (gid_cache, GINT_TO_POINTER (gid));
if (name)
return name;
#if defined (HAVE_POSIX_GETGRGID_R)
getgrgid_r (gid, &gbuf, buffer, sizeof(buffer), &gbufp);
#elif defined (HAVE_NONPOSIX_GETGRGID_R)
gbufp = getgrgid_r (gid, &gbuf, buffer, sizeof(buffer));
#else
gbufp = getgrgid (gid);
#endif
if (gbufp != NULL &&
gbufp->gr_name != NULL &&
gbufp->gr_name[0] != 0)
name = convert_pwd_string_to_utf8 (gbufp->gr_name);
else
name = g_strdup_printf("%d", (int)gid);
g_hash_table_replace (gid_cache, GINT_TO_POINTER (gid), name);
return name;
}
static char *
get_groupname_from_gid (gid_t gid)
{
char *res;
char *name;
G_LOCK (gid_cache);
name = lookup_gid_name (gid);
res = g_strdup (name);
G_UNLOCK (gid_cache);
return res;
}
#endif /* !G_OS_WIN32 */
static char *
get_content_type (const char *basename,
const char *path,
GLocalFileStat *statbuf,
gboolean is_symlink,
gboolean symlink_broken,
GFileQueryInfoFlags flags,
gboolean fast)
{
if (is_symlink &&
(symlink_broken || (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS)))
return g_strdup ("inode/symlink");
else if (statbuf != NULL && S_ISDIR(statbuf->st_mode))
return g_strdup ("inode/directory");
#ifndef G_OS_WIN32
else if (statbuf != NULL && S_ISCHR(statbuf->st_mode))
return g_strdup ("inode/chardevice");
else if (statbuf != NULL && S_ISBLK(statbuf->st_mode))
return g_strdup ("inode/blockdevice");
else if (statbuf != NULL && S_ISFIFO(statbuf->st_mode))
return g_strdup ("inode/fifo");
#endif
#ifdef S_ISSOCK
else if (statbuf != NULL && S_ISSOCK(statbuf->st_mode))
return g_strdup ("inode/socket");
#endif
else
{
char *content_type;
gboolean result_uncertain;
content_type = g_content_type_guess (basename, NULL, 0, &result_uncertain);
#ifndef G_OS_WIN32
if (!fast && result_uncertain && path != NULL)
{
guchar sniff_buffer[4096];
gsize sniff_length;
int fd;
sniff_length = _g_unix_content_type_get_sniff_len ();
if (sniff_length > 4096)
sniff_length = 4096;
#ifdef O_NOATIME
fd = g_open (path, O_RDONLY | O_NOATIME, 0);
if (fd < 0 && errno == EPERM)
#endif
fd = g_open (path, O_RDONLY, 0);
if (fd != -1)
{
ssize_t res;
res = read (fd, sniff_buffer, sniff_length);
(void) g_close (fd, NULL);
if (res >= 0)
{
g_free (content_type);
content_type = g_content_type_guess (basename, sniff_buffer, res, NULL);
}
}
}
#endif
return content_type;
}
}
/* @stat_buf is the pre-calculated result of stat(path), or %NULL if that failed. */
static void
get_thumbnail_attributes (const char *path,
GFileInfo *info,
const GStatBuf *stat_buf)
{
GChecksum *checksum;
char *uri;
char *filename;
char *basename;
uri = g_filename_to_uri (path, NULL, NULL);
checksum = g_checksum_new (G_CHECKSUM_MD5);
g_checksum_update (checksum, (const guchar *) uri, strlen (uri));
basename = g_strconcat (g_checksum_get_string (checksum), ".png", NULL);
g_checksum_free (checksum);
filename = g_build_filename (g_get_user_cache_dir (),
"thumbnails", "large", basename,
NULL);
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
_g_file_info_set_attribute_byte_string_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAIL_PATH, filename);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAIL_IS_VALID,
thumbnail_verify (filename, uri, stat_buf));
}
else
{
g_free (filename);
filename = g_build_filename (g_get_user_cache_dir (),
"thumbnails", "normal", basename,
NULL);
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
_g_file_info_set_attribute_byte_string_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAIL_PATH, filename);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAIL_IS_VALID,
thumbnail_verify (filename, uri, stat_buf));
}
else
{
g_free (filename);
filename = g_build_filename (g_get_user_cache_dir (),
"thumbnails", "fail",
"gnome-thumbnail-factory",
basename,
NULL);
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAILING_FAILED, TRUE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_THUMBNAIL_IS_VALID,
thumbnail_verify (filename, uri, stat_buf));
}
}
}
g_free (basename);
g_free (filename);
g_free (uri);
}
#ifdef G_OS_WIN32
static void
win32_get_file_user_info (const gchar *filename,
gchar **group_name,
gchar **user_name,
gchar **real_name)
{
PSECURITY_DESCRIPTOR psd = NULL;
DWORD sd_size = 0; /* first call calculates the size required */
wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
if ((GetFileSecurityW (wfilename,
GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION,
NULL,
sd_size,
&sd_size) || (ERROR_INSUFFICIENT_BUFFER == GetLastError())) &&
(psd = g_try_malloc (sd_size)) != NULL &&
GetFileSecurityW (wfilename,
GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION,
psd,
sd_size,
&sd_size))
{
PSID psid = 0;
BOOL defaulted;
SID_NAME_USE name_use = 0; /* don't care? */
wchar_t *name = NULL;
wchar_t *domain = NULL;
DWORD name_len = 0;
DWORD domain_len = 0;
/* get the user name */
do {
if (!user_name)
break;
if (!GetSecurityDescriptorOwner (psd, &psid, &defaulted))
break;
if (!LookupAccountSidW (NULL, /* local machine */
psid,
name, &name_len,
domain, &domain_len, /* no domain info yet */
&name_use) && (ERROR_INSUFFICIENT_BUFFER != GetLastError()))
break;
name = g_try_malloc (name_len * sizeof (wchar_t));
domain = g_try_malloc (domain_len * sizeof (wchar_t));
if (name && domain &&
LookupAccountSidW (NULL, /* local machine */
psid,
name, &name_len,
domain, &domain_len, /* no domain info yet */
&name_use))
{
*user_name = g_utf16_to_utf8 (name, -1, NULL, NULL, NULL);
}
g_free (name);
g_free (domain);
} while (FALSE);
/* get the group name */
do {
if (!group_name)
break;
if (!GetSecurityDescriptorGroup (psd, &psid, &defaulted))
break;
if (!LookupAccountSidW (NULL, /* local machine */
psid,
name, &name_len,
domain, &domain_len, /* no domain info yet */
&name_use) && (ERROR_INSUFFICIENT_BUFFER != GetLastError()))
break;
name = g_try_malloc (name_len * sizeof (wchar_t));
domain = g_try_malloc (domain_len * sizeof (wchar_t));
if (name && domain &&
LookupAccountSidW (NULL, /* local machine */
psid,
name, &name_len,
domain, &domain_len, /* no domain info yet */
&name_use))
{
*group_name = g_utf16_to_utf8 (name, -1, NULL, NULL, NULL);
}
g_free (name);
g_free (domain);
} while (FALSE);
/* TODO: get real name */
g_free (psd);
}
g_free (wfilename);
}
#endif /* G_OS_WIN32 */
#ifndef G_OS_WIN32
/* support for '.hidden' files */
G_LOCK_DEFINE_STATIC (hidden_cache);
static GHashTable *hidden_cache;
static gboolean
remove_from_hidden_cache (gpointer user_data)
{
G_LOCK (hidden_cache);
g_hash_table_remove (hidden_cache, user_data);
G_UNLOCK (hidden_cache);
return FALSE;
}
static GHashTable *
read_hidden_file (const gchar *dirname)
{
gchar *contents = NULL;
gchar *filename;
filename = g_build_path ("/", dirname, ".hidden", NULL);
g_file_get_contents (filename, &contents, NULL, NULL);
g_free (filename);
if (contents != NULL)
{
GHashTable *table;
gchar **lines;
gint i;
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
lines = g_strsplit (contents, "\n", 0);
g_free (contents);
for (i = 0; lines[i]; i++)
/* hash table takes the individual strings... */
g_hash_table_add (table, lines[i]);
/* ... so we only free the container. */
g_free (lines);
return table;
}
else
return NULL;
}
static void
maybe_unref_hash_table (gpointer data)
{
if (data != NULL)
g_hash_table_unref (data);
}
static gboolean
file_is_hidden (const gchar *path,
const gchar *basename)
{
gboolean result;
gchar *dirname;
gpointer table;
dirname = g_path_get_dirname (path);
G_LOCK (hidden_cache);
if G_UNLIKELY (hidden_cache == NULL)
hidden_cache = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, maybe_unref_hash_table);
if (!g_hash_table_lookup_extended (hidden_cache, dirname,
NULL, &table))
{
gchar *mydirname;
GSource *remove_from_cache_source;
g_hash_table_insert (hidden_cache,
mydirname = g_strdup (dirname),
table = read_hidden_file (dirname));
remove_from_cache_source = g_timeout_source_new_seconds (5);
g_source_set_priority (remove_from_cache_source, G_PRIORITY_DEFAULT);
g_source_set_callback (remove_from_cache_source,
remove_from_hidden_cache,
mydirname,
NULL);
g_source_attach (remove_from_cache_source,
GLIB_PRIVATE_CALL (g_get_worker_context) ());
g_source_unref (remove_from_cache_source);
}
result = table != NULL && g_hash_table_contains (table, basename);
G_UNLOCK (hidden_cache);
g_free (dirname);
return result;
}
#endif /* !G_OS_WIN32 */
void
_g_local_file_info_get_nostat (GFileInfo *info,
const char *basename,
const char *path,
GFileAttributeMatcher *attribute_matcher)
{
g_file_info_set_name (info, basename);
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_DISPLAY_NAME))
{
char *display_name = g_filename_display_basename (path);
/* look for U+FFFD REPLACEMENT CHARACTER */
if (strstr (display_name, "\357\277\275") != NULL)
{
char *p = display_name;
display_name = g_strconcat (display_name, _(" (invalid encoding)"), NULL);
g_free (p);
}
g_file_info_set_display_name (info, display_name);
g_free (display_name);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_EDIT_NAME))
{
char *edit_name = g_filename_display_basename (path);
g_file_info_set_edit_name (info, edit_name);
g_free (edit_name);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_COPY_NAME))
{
char *copy_name = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL);
if (copy_name)
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_COPY_NAME, copy_name);
g_free (copy_name);
}
}
static const char *
get_icon_name (const char *path,
gboolean use_symbolic,
gboolean *with_fallbacks_out)
{
const char *name = NULL;
gboolean with_fallbacks = TRUE;
if (strcmp (path, g_get_home_dir ()) == 0)
{
name = use_symbolic ? "user-home-symbolic" : "user-home";
with_fallbacks = FALSE;
}
else if (strcmp (path, g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP)) == 0)
{
name = use_symbolic ? "user-desktop-symbolic" : "user-desktop";
with_fallbacks = FALSE;
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS)) == 0)
{
name = use_symbolic ? "folder-documents-symbolic" : "folder-documents";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD)) == 0)
{
name = use_symbolic ? "folder-download-symbolic" : "folder-download";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_MUSIC)) == 0)
{
name = use_symbolic ? "folder-music-symbolic" : "folder-music";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_PICTURES)) == 0)
{
name = use_symbolic ? "folder-pictures-symbolic" : "folder-pictures";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_PUBLIC_SHARE)) == 0)
{
name = use_symbolic ? "folder-publicshare-symbolic" : "folder-publicshare";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_TEMPLATES)) == 0)
{
name = use_symbolic ? "folder-templates-symbolic" : "folder-templates";
}
else if (g_strcmp0 (path, g_get_user_special_dir (G_USER_DIRECTORY_VIDEOS)) == 0)
{
name = use_symbolic ? "folder-videos-symbolic" : "folder-videos";
}
else
{
name = NULL;
}
if (with_fallbacks_out != NULL)
*with_fallbacks_out = with_fallbacks;
return name;
}
static GIcon *
get_icon (const char *path,
const char *content_type,
gboolean is_folder,
gboolean use_symbolic)
{
GIcon *icon = NULL;
const char *icon_name;
gboolean with_fallbacks;
icon_name = get_icon_name (path, use_symbolic, &with_fallbacks);
if (icon_name != NULL)
{
if (with_fallbacks)
icon = g_themed_icon_new_with_default_fallbacks (icon_name);
else
icon = g_themed_icon_new (icon_name);
}
else
{
if (use_symbolic)
icon = g_content_type_get_symbolic_icon (content_type);
else
icon = g_content_type_get_icon (content_type);
if (G_IS_THEMED_ICON (icon) && is_folder)
{
g_themed_icon_append_name (G_THEMED_ICON (icon), use_symbolic ? "folder-symbolic" : "folder");
}
}
return icon;
}
GFileInfo *
_g_local_file_info_get (const char *basename,
const char *path,
GFileAttributeMatcher *attribute_matcher,
GFileQueryInfoFlags flags,
GLocalParentFileInfo *parent_info,
GError **error)
{
GFileInfo *info;
GLocalFileStat statbuf;
#ifdef S_ISLNK
struct stat statbuf2;
#endif
int res;
gboolean stat_ok;
gboolean is_symlink, symlink_broken;
#ifdef G_OS_WIN32
DWORD dos_attributes;
#endif
char *symlink_target;
GVfs *vfs;
GVfsClass *class;
guint64 device;
info = g_file_info_new ();
/* Make sure we don't set any unwanted attributes */
g_file_info_set_attribute_mask (info, attribute_matcher);
_g_local_file_info_get_nostat (info, basename, path, attribute_matcher);
if (attribute_matcher == NULL)
{
g_file_info_unset_attribute_mask (info);
return info;
}
#ifndef G_OS_WIN32
res = g_lstat (path, &statbuf);
#else
{
wchar_t *wpath = g_utf8_to_utf16 (path, -1, NULL, NULL, error);
int len;
if (wpath == NULL)
{
g_object_unref (info);
return NULL;
}
len = wcslen (wpath);
while (len > 0 && G_IS_DIR_SEPARATOR (wpath[len-1]))
len--;
if (len > 0 &&
(!g_path_is_absolute (path) || len > g_path_skip_root (path) - path))
wpath[len] = '\0';
res = _wstati64 (wpath, &statbuf);
dos_attributes = GetFileAttributesW (wpath);
g_free (wpath);
}
#endif
if (res == -1)
{
int errsv = errno;
/* Don't bail out if we get Permission denied (SELinux?) */
if (errsv != EACCES)
{
char *display_name = g_filename_display_name (path);
g_object_unref (info);
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error when getting information for file '%s': %s"),
display_name, g_strerror (errsv));
g_free (display_name);
return NULL;
}
}
/* Even if stat() fails, try to get as much as other attributes possible */
stat_ok = res != -1;
if (stat_ok)
device = statbuf.st_dev;
else
device = 0;
#ifdef S_ISLNK
is_symlink = stat_ok && S_ISLNK (statbuf.st_mode);
#else
is_symlink = FALSE;
#endif
symlink_broken = FALSE;
#ifdef S_ISLNK
if (is_symlink)
{
g_file_info_set_is_symlink (info, TRUE);
/* Unless NOFOLLOW was set we default to following symlinks */
if (!(flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS))
{
res = stat (path, &statbuf2);
/* Report broken links as symlinks */
if (res != -1)
{
statbuf = statbuf2;
stat_ok = TRUE;
}
else
symlink_broken = TRUE;
}
}
#endif
if (stat_ok)
set_info_from_stat (info, &statbuf, attribute_matcher);
#ifdef G_OS_UNIX
if (stat_ok && _g_local_file_is_lost_found_dir (path, statbuf.st_dev))
g_file_info_set_is_hidden (info, TRUE);
#endif
#ifndef G_OS_WIN32
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_IS_HIDDEN))
{
if (basename != NULL &&
(basename[0] == '.' ||
file_is_hidden (path, basename)))
g_file_info_set_is_hidden (info, TRUE);
}
if (basename != NULL && basename[strlen (basename) -1] == '~' &&
(stat_ok && S_ISREG (statbuf.st_mode)))
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_IS_BACKUP, TRUE);
#else
if (dos_attributes & FILE_ATTRIBUTE_HIDDEN)
g_file_info_set_is_hidden (info, TRUE);
if (dos_attributes & FILE_ATTRIBUTE_ARCHIVE)
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_DOS_IS_ARCHIVE, TRUE);
if (dos_attributes & FILE_ATTRIBUTE_SYSTEM)
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_DOS_IS_SYSTEM, TRUE);
#endif
symlink_target = NULL;
#ifdef S_ISLNK
if (is_symlink)
{
symlink_target = read_link (path);
if (symlink_target &&
_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_SYMLINK_TARGET))
g_file_info_set_symlink_target (info, symlink_target);
}
#endif
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_CONTENT_TYPE) ||
_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_ICON) ||
_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_SYMBOLIC_ICON))
{
char *content_type = get_content_type (basename, path, stat_ok ? &statbuf : NULL, is_symlink, symlink_broken, flags, FALSE);
if (content_type)
{
g_file_info_set_content_type (info, content_type);
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_ICON)
|| _g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_SYMBOLIC_ICON))
{
GIcon *icon;
/* non symbolic icon */
icon = get_icon (path, content_type, S_ISDIR (statbuf.st_mode), FALSE);
if (icon != NULL)
{
g_file_info_set_icon (info, icon);
g_object_unref (icon);
}
/* symbolic icon */
icon = get_icon (path, content_type, S_ISDIR (statbuf.st_mode), TRUE);
if (icon != NULL)
{
g_file_info_set_symbolic_icon (info, icon);
g_object_unref (icon);
}
}
g_free (content_type);
}
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE))
{
char *content_type = get_content_type (basename, path, stat_ok ? &statbuf : NULL, is_symlink, symlink_broken, flags, TRUE);
if (content_type)
{
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE, content_type);
g_free (content_type);
}
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_OWNER_USER))
{
char *name = NULL;
#ifdef G_OS_WIN32
win32_get_file_user_info (path, NULL, &name, NULL);
#else
if (stat_ok)
name = get_username_from_uid (statbuf.st_uid);
#endif
if (name)
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_OWNER_USER, name);
g_free (name);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_OWNER_USER_REAL))
{
char *name = NULL;
#ifdef G_OS_WIN32
win32_get_file_user_info (path, NULL, NULL, &name);
#else
if (stat_ok)
name = get_realname_from_uid (statbuf.st_uid);
#endif
if (name)
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_OWNER_USER_REAL, name);
g_free (name);
}
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_OWNER_GROUP))
{
char *name = NULL;
#ifdef G_OS_WIN32
win32_get_file_user_info (path, &name, NULL, NULL);
#else
if (stat_ok)
name = get_groupname_from_gid (statbuf.st_gid);
#endif
if (name)
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_OWNER_GROUP, name);
g_free (name);
}
if (stat_ok && parent_info && parent_info->device != 0 &&
_g_file_attribute_matcher_matches_id (attribute_matcher, G_FILE_ATTRIBUTE_ID_UNIX_IS_MOUNTPOINT) &&
statbuf.st_dev != parent_info->device)
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_UNIX_IS_MOUNTPOINT, TRUE);
if (stat_ok)
get_access_rights (attribute_matcher, info, path, &statbuf, parent_info);
#ifdef HAVE_SELINUX
get_selinux_context (path, info, attribute_matcher, (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS) == 0);
#endif
get_xattrs (path, TRUE, info, attribute_matcher, (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS) == 0);
get_xattrs (path, FALSE, info, attribute_matcher, (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS) == 0);
if (_g_file_attribute_matcher_matches_id (attribute_matcher,
G_FILE_ATTRIBUTE_ID_THUMBNAIL_PATH))
{
if (stat_ok)
get_thumbnail_attributes (path, info, &statbuf);
else
get_thumbnail_attributes (path, info, NULL);
}
vfs = g_vfs_get_default ();
class = G_VFS_GET_CLASS (vfs);
if (class->local_file_add_info)
{
class->local_file_add_info (vfs,
path,
device,
attribute_matcher,
info,
NULL,
&parent_info->extra_data,
&parent_info->free_extra_data);
}
g_file_info_unset_attribute_mask (info);
g_free (symlink_target);
return info;
}
GFileInfo *
_g_local_file_info_get_from_fd (int fd,
const char *attributes,
GError **error)
{
GLocalFileStat stat_buf;
GFileAttributeMatcher *matcher;
GFileInfo *info;
#ifdef G_OS_WIN32
#define FSTAT _fstati64
#else
#define FSTAT fstat
#endif
if (FSTAT (fd, &stat_buf) == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error when getting information for file descriptor: %s"),
g_strerror (errsv));
return NULL;
}
info = g_file_info_new ();
matcher = g_file_attribute_matcher_new (attributes);
/* Make sure we don't set any unwanted attributes */
g_file_info_set_attribute_mask (info, matcher);
set_info_from_stat (info, &stat_buf, matcher);
#ifdef HAVE_SELINUX
if (_g_file_attribute_matcher_matches_id (matcher, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT) &&
is_selinux_enabled ())
{
char *context;
if (fgetfilecon_raw (fd, &context) >= 0)
{
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_SELINUX_CONTEXT, context);
freecon (context);
}
}
#endif
get_xattrs_from_fd (fd, TRUE, info, matcher);
get_xattrs_from_fd (fd, FALSE, info, matcher);
g_file_attribute_matcher_unref (matcher);
g_file_info_unset_attribute_mask (info);
return info;
}
static gboolean
get_uint32 (const GFileAttributeValue *value,
guint32 *val_out,
GError **error)
{
if (value->type != G_FILE_ATTRIBUTE_TYPE_UINT32)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid attribute type (uint32 expected)"));
return FALSE;
}
*val_out = value->u.uint32;
return TRUE;
}
#ifdef HAVE_UTIMES
static gboolean
get_uint64 (const GFileAttributeValue *value,
guint64 *val_out,
GError **error)
{
if (value->type != G_FILE_ATTRIBUTE_TYPE_UINT64)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid attribute type (uint64 expected)"));
return FALSE;
}
*val_out = value->u.uint64;
return TRUE;
}
#endif
#if defined(HAVE_SYMLINK)
static gboolean
get_byte_string (const GFileAttributeValue *value,
const char **val_out,
GError **error)
{
if (value->type != G_FILE_ATTRIBUTE_TYPE_BYTE_STRING)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid attribute type (byte string expected)"));
return FALSE;
}
*val_out = value->u.string;
return TRUE;
}
#endif
#ifdef HAVE_SELINUX
static gboolean
get_string (const GFileAttributeValue *value,
const char **val_out,
GError **error)
{
if (value->type != G_FILE_ATTRIBUTE_TYPE_STRING)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid attribute type (byte string expected)"));
return FALSE;
}
*val_out = value->u.string;
return TRUE;
}
#endif
static gboolean
set_unix_mode (char *filename,
GFileQueryInfoFlags flags,
const GFileAttributeValue *value,
GError **error)
{
guint32 val = 0;
int res = 0;
if (!get_uint32 (value, &val, error))
return FALSE;
#ifdef HAVE_SYMLINK
if (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS) {
#ifdef HAVE_LCHMOD
res = lchmod (filename, val);
#else
struct stat statbuf;
/* Calling chmod on a symlink changes permissions on the symlink.
* We don't want to do this, so we need to check for a symlink */
res = g_lstat (filename, &statbuf);
if (res == 0 && S_ISLNK (statbuf.st_mode))
{
g_set_error_literal (error, G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
_("Cannot set permissions on symlinks"));
return FALSE;
}
else if (res == 0)
res = g_chmod (filename, val);
#endif
} else
#endif
res = g_chmod (filename, val);
if (res == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting permissions: %s"),
g_strerror (errsv));
return FALSE;
}
return TRUE;
}
#ifdef HAVE_CHOWN
static gboolean
set_unix_uid_gid (char *filename,
const GFileAttributeValue *uid_value,
const GFileAttributeValue *gid_value,
GFileQueryInfoFlags flags,
GError **error)
{
int res;
guint32 val = 0;
uid_t uid;
gid_t gid;
if (uid_value)
{
if (!get_uint32 (uid_value, &val, error))
return FALSE;
uid = val;
}
else
uid = -1;
if (gid_value)
{
if (!get_uint32 (gid_value, &val, error))
return FALSE;
gid = val;
}
else
gid = -1;
#ifdef HAVE_LCHOWN
if (flags & G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS)
res = lchown (filename, uid, gid);
else
#endif
res = chown (filename, uid, gid);
if (res == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting owner: %s"),
g_strerror (errsv));
return FALSE;
}
return TRUE;
}
#endif
#ifdef HAVE_SYMLINK
static gboolean
set_symlink (char *filename,
const GFileAttributeValue *value,
GError **error)
{
const char *val;
struct stat statbuf;
if (!get_byte_string (value, &val, error))
return FALSE;
if (val == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("symlink must be non-NULL"));
return FALSE;
}
if (g_lstat (filename, &statbuf))
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting symlink: %s"),
g_strerror (errsv));
return FALSE;
}
if (!S_ISLNK (statbuf.st_mode))
{
g_set_error_literal (error, G_IO_ERROR,
G_IO_ERROR_NOT_SYMBOLIC_LINK,
_("Error setting symlink: file is not a symlink"));
return FALSE;
}
if (g_unlink (filename))
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting symlink: %s"),
g_strerror (errsv));
return FALSE;
}
if (symlink (filename, val) != 0)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting symlink: %s"),
g_strerror (errsv));
return FALSE;
}
return TRUE;
}
#endif
#ifdef HAVE_UTIMES
static int
lazy_stat (char *filename,
struct stat *statbuf,
gboolean *called_stat)
{
int res;
if (*called_stat)
return 0;
res = g_stat (filename, statbuf);
if (res == 0)
*called_stat = TRUE;
return res;
}
static gboolean
set_mtime_atime (char *filename,
const GFileAttributeValue *mtime_value,
const GFileAttributeValue *mtime_usec_value,
const GFileAttributeValue *atime_value,
const GFileAttributeValue *atime_usec_value,
GError **error)
{
int res;
guint64 val = 0;
guint32 val_usec = 0;
struct stat statbuf;
gboolean got_stat = FALSE;
struct timeval times[2] = { {0, 0}, {0, 0} };
/* ATIME */
if (atime_value)
{
if (!get_uint64 (atime_value, &val, error))
return FALSE;
times[0].tv_sec = val;
}
else
{
if (lazy_stat (filename, &statbuf, &got_stat) == 0)
{
times[0].tv_sec = statbuf.st_mtime;
#if defined (HAVE_STRUCT_STAT_ST_ATIMENSEC)
times[0].tv_usec = statbuf.st_atimensec / 1000;
#elif defined (HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC)
times[0].tv_usec = statbuf.st_atim.tv_nsec / 1000;
#endif
}
}
if (atime_usec_value)
{
if (!get_uint32 (atime_usec_value, &val_usec, error))
return FALSE;
times[0].tv_usec = val_usec;
}
/* MTIME */
if (mtime_value)
{
if (!get_uint64 (mtime_value, &val, error))
return FALSE;
times[1].tv_sec = val;
}
else
{
if (lazy_stat (filename, &statbuf, &got_stat) == 0)
{
times[1].tv_sec = statbuf.st_mtime;
#if defined (HAVE_STRUCT_STAT_ST_MTIMENSEC)
times[1].tv_usec = statbuf.st_mtimensec / 1000;
#elif defined (HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
times[1].tv_usec = statbuf.st_mtim.tv_nsec / 1000;
#endif
}
}
if (mtime_usec_value)
{
if (!get_uint32 (mtime_usec_value, &val_usec, error))
return FALSE;
times[1].tv_usec = val_usec;
}
res = utimes (filename, times);
if (res == -1)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting modification or access time: %s"),
g_strerror (errsv));
return FALSE;
}
return TRUE;
}
#endif
#ifdef HAVE_SELINUX
static gboolean
set_selinux_context (char *filename,
const GFileAttributeValue *value,
GError **error)
{
const char *val;
if (!get_string (value, &val, error))
return FALSE;
if (val == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("SELinux context must be non-NULL"));
return FALSE;
}
if (is_selinux_enabled ()) {
security_context_t val_s;
val_s = g_strdup (val);
if (setfilecon_raw (filename, val_s) < 0)
{
int errsv = errno;
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errsv),
_("Error setting SELinux context: %s"),
g_strerror (errsv));
return FALSE;
}
g_free (val_s);
} else {
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("SELinux is not enabled on this system"));
return FALSE;
}
return TRUE;
}
#endif
gboolean
_g_local_file_info_set_attribute (char *filename,
const char *attribute,
GFileAttributeType type,
gpointer value_p,
GFileQueryInfoFlags flags,
GCancellable *cancellable,
GError **error)
{
GFileAttributeValue value = { 0 };
GVfsClass *class;
GVfs *vfs;
_g_file_attribute_value_set_from_pointer (&value, type, value_p, FALSE);
if (strcmp (attribute, G_FILE_ATTRIBUTE_UNIX_MODE) == 0)
return set_unix_mode (filename, flags, &value, error);
#ifdef HAVE_CHOWN
else if (strcmp (attribute, G_FILE_ATTRIBUTE_UNIX_UID) == 0)
return set_unix_uid_gid (filename, &value, NULL, flags, error);
else if (strcmp (attribute, G_FILE_ATTRIBUTE_UNIX_GID) == 0)
return set_unix_uid_gid (filename, NULL, &value, flags, error);
#endif
#ifdef HAVE_SYMLINK
else if (strcmp (attribute, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET) == 0)
return set_symlink (filename, &value, error);
#endif
#ifdef HAVE_UTIMES
else if (strcmp (attribute, G_FILE_ATTRIBUTE_TIME_MODIFIED) == 0)
return set_mtime_atime (filename, &value, NULL, NULL, NULL, error);
else if (strcmp (attribute, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC) == 0)
return set_mtime_atime (filename, NULL, &value, NULL, NULL, error);
else if (strcmp (attribute, G_FILE_ATTRIBUTE_TIME_ACCESS) == 0)
return set_mtime_atime (filename, NULL, NULL, &value, NULL, error);
else if (strcmp (attribute, G_FILE_ATTRIBUTE_TIME_ACCESS_USEC) == 0)
return set_mtime_atime (filename, NULL, NULL, NULL, &value, error);
#endif
#ifdef HAVE_XATTR
else if (g_str_has_prefix (attribute, "xattr::"))
return set_xattr (filename, attribute, &value, error);
else if (g_str_has_prefix (attribute, "xattr-sys::"))
return set_xattr (filename, attribute, &value, error);
#endif
#ifdef HAVE_SELINUX
else if (strcmp (attribute, G_FILE_ATTRIBUTE_SELINUX_CONTEXT) == 0)
return set_selinux_context (filename, &value, error);
#endif
vfs = g_vfs_get_default ();
class = G_VFS_GET_CLASS (vfs);
if (class->local_file_set_attributes)
{
GFileInfo *info;
info = g_file_info_new ();
g_file_info_set_attribute (info,
attribute,
type,
value_p);
if (!class->local_file_set_attributes (vfs, filename,
info,
flags, cancellable,
error))
{
g_object_unref (info);
return FALSE;
}
if (g_file_info_get_attribute_status (info, attribute) == G_FILE_ATTRIBUTE_STATUS_SET)
{
g_object_unref (info);
return TRUE;
}
g_object_unref (info);
}
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("Setting attribute %s not supported"), attribute);
return FALSE;
}
gboolean
_g_local_file_info_set_attributes (char *filename,
GFileInfo *info,
GFileQueryInfoFlags flags,
GCancellable *cancellable,
GError **error)
{
GFileAttributeValue *value;
#ifdef HAVE_CHOWN
GFileAttributeValue *uid, *gid;
#endif
#ifdef HAVE_UTIMES
GFileAttributeValue *mtime, *mtime_usec, *atime, *atime_usec;
#endif
#if defined (HAVE_CHOWN) || defined (HAVE_UTIMES)
GFileAttributeStatus status;
#endif
gboolean res;
GVfsClass *class;
GVfs *vfs;
/* Handles setting multiple specified data in a single set, and takes care
of ordering restrictions when setting attributes */
res = TRUE;
/* Set symlink first, since this recreates the file */
#ifdef HAVE_SYMLINK
value = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET);
if (value)
{
if (!set_symlink (filename, value, error))
{
value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
else
value->status = G_FILE_ATTRIBUTE_STATUS_SET;
}
#endif
#ifdef HAVE_CHOWN
/* Group uid and gid setting into one call
* Change ownership before permissions, since ownership changes can
change permissions (e.g. setuid)
*/
uid = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_UNIX_UID);
gid = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_UNIX_GID);
if (uid || gid)
{
if (!set_unix_uid_gid (filename, uid, gid, flags, error))
{
status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
else
status = G_FILE_ATTRIBUTE_STATUS_SET;
if (uid)
uid->status = status;
if (gid)
gid->status = status;
}
#endif
value = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_UNIX_MODE);
if (value)
{
if (!set_unix_mode (filename, flags, value, error))
{
value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
else
value->status = G_FILE_ATTRIBUTE_STATUS_SET;
}
#ifdef HAVE_UTIMES
/* Group all time settings into one call
* Change times as the last thing to avoid it changing due to metadata changes
*/
mtime = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
mtime_usec = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
atime = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_TIME_ACCESS);
atime_usec = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_TIME_ACCESS_USEC);
if (mtime || mtime_usec || atime || atime_usec)
{
if (!set_mtime_atime (filename, mtime, mtime_usec, atime, atime_usec, error))
{
status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
else
status = G_FILE_ATTRIBUTE_STATUS_SET;
if (mtime)
mtime->status = status;
if (mtime_usec)
mtime_usec->status = status;
if (atime)
atime->status = status;
if (atime_usec)
atime_usec->status = status;
}
#endif
/* xattrs are handled by default callback */
/* SELinux context */
#ifdef HAVE_SELINUX
if (is_selinux_enabled ()) {
value = _g_file_info_get_attribute_value (info, G_FILE_ATTRIBUTE_SELINUX_CONTEXT);
if (value)
{
if (!set_selinux_context (filename, value, error))
{
value->status = G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING;
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
else
value->status = G_FILE_ATTRIBUTE_STATUS_SET;
}
}
#endif
vfs = g_vfs_get_default ();
class = G_VFS_GET_CLASS (vfs);
if (class->local_file_set_attributes)
{
if (!class->local_file_set_attributes (vfs, filename,
info,
flags, cancellable,
error))
{
res = FALSE;
/* Don't set error multiple times */
error = NULL;
}
}
return res;
}
Reference in New Issue View Git Blame Copy Permalink