/**
* Gets the attributes of a file
* @param meta is the structure where to store meta data (attributes) of
* the file
* @param fileinfo is a glib structure that contains a lot of informations
* about the file and from which we want to keep a few.
*/
static void get_file_attributes(meta_data_t *meta, GFileInfo *fileinfo)
{
if (meta != NULL)
{
meta->inode = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_UNIX_INODE);
meta->owner = g_file_info_get_attribute_as_string(fileinfo, G_FILE_ATTRIBUTE_OWNER_USER);
meta->group = g_file_info_get_attribute_as_string(fileinfo, G_FILE_ATTRIBUTE_OWNER_GROUP);
meta->uid = g_file_info_get_attribute_uint32(fileinfo, G_FILE_ATTRIBUTE_UNIX_UID);
meta->gid = g_file_info_get_attribute_uint32(fileinfo, G_FILE_ATTRIBUTE_UNIX_GID);
meta->atime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_ACCESS);
meta->ctime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_CHANGED);
meta->mtime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_MODIFIED);
meta->mode = g_file_info_get_attribute_uint32(fileinfo, G_FILE_ATTRIBUTE_UNIX_MODE);
meta->size = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_STANDARD_SIZE);
/* Do the right things with specific cases */
if (meta->file_type == G_FILE_TYPE_SYMBOLIC_LINK)
{
meta->link = (gchar *) g_file_info_get_attribute_byte_string(fileinfo, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET);
}
else
{
meta->link = g_strdup("");
}
}
}
static void
free_space_cb (GObject *obj, GAsyncResult *res, gpointer data)
{
RBAndroidSource *source = RB_ANDROID_SOURCE (data);
RBAndroidSourcePrivate *priv = GET_PRIVATE(source);
GFileInfo *info;
GError *error = NULL;
info = g_file_query_filesystem_info_finish (G_FILE (obj), res, &error);
if (info == NULL) {
rb_debug ("error querying filesystem free space: %s", error->message);
g_clear_error (&error);
} else {
priv->storage_free_space_next += g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
priv->storage_capacity_next += g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE);
rb_debug ("capacity: %lu, free space: %lu", priv->storage_capacity_next, priv->storage_free_space_next);
}
priv->query_storage = priv->query_storage->next;
if (priv->query_storage != NULL) {
update_free_space_next (source);
} else {
priv->storage_free_space = priv->storage_free_space_next;
priv->storage_capacity = priv->storage_capacity_next;
}
}
static const gchar *
xfdesktop_special_file_icon_peek_tooltip(XfdesktopIcon *icon)
{
XfdesktopSpecialFileIcon *special_file_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon);
if(!special_file_icon->priv->tooltip) {
GFileInfo *info = xfdesktop_file_icon_peek_file_info(XFDESKTOP_FILE_ICON(icon));
if(!info)
return NULL;
if(XFDESKTOP_SPECIAL_FILE_ICON_TRASH == special_file_icon->priv->type) {
if(special_file_icon->priv->trash_item_count == 0) {
special_file_icon->priv->tooltip = g_strdup(_("Trash is empty"));
} else {
special_file_icon->priv->tooltip = g_strdup_printf(g_dngettext(GETTEXT_PACKAGE,
_("Trash contains one item"),
_("Trash contains %d items"),
special_file_icon->priv->trash_item_count),
special_file_icon->priv->trash_item_count);
}
} else {
const gchar *description;
gchar *size_string, *time_string;
guint64 size, mtime;
if(special_file_icon->priv->type == XFDESKTOP_SPECIAL_FILE_ICON_FILESYSTEM)
description = _("File System");
else if(special_file_icon->priv->type == XFDESKTOP_SPECIAL_FILE_ICON_HOME)
description = _("Home");
else {
description = g_file_info_get_attribute_string(info,
G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION);
}
size = g_file_info_get_attribute_uint64(info,
G_FILE_ATTRIBUTE_STANDARD_SIZE);
size_string = g_format_size(size);
mtime = g_file_info_get_attribute_uint64(info,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
time_string = xfdesktop_file_utils_format_time_for_display(mtime);
special_file_icon->priv->tooltip =
g_strdup_printf(_("%s\nSize: %s\nLast modified: %s"),
description, size_string, time_string);
g_free(size_string);
g_free(time_string);
}
}
return special_file_icon->priv->tooltip;
}
static int
file_sort_func (gconstpointer a,
gconstpointer b)
{
GFileInfo *file_a = G_FILE_INFO (a);
GFileInfo *file_b = G_FILE_INFO (b);
guint64 modified_a, modified_b;
modified_a = g_file_info_get_attribute_uint64 (file_a, G_FILE_ATTRIBUTE_TIME_MODIFIED);
modified_b = g_file_info_get_attribute_uint64 (file_b, G_FILE_ATTRIBUTE_TIME_MODIFIED);
return modified_b - modified_a;
}
/**
* gs_plugin_xdg_app_set_metadata_installed:
*/
static void
gs_plugin_xdg_app_set_metadata_installed (GsApp *app, XdgAppInstalledRef *xref)
{
guint64 mtime;
guint64 size_installed;
g_autofree gchar *metadata_fn = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GFileInfo) info = NULL;
/* for all types */
gs_plugin_xdg_app_set_metadata (app, XDG_APP_REF (xref));
/* get the last time the app was updated */
metadata_fn = g_build_filename (xdg_app_installed_ref_get_deploy_dir (xref),
"..",
"active",
NULL);
file = g_file_new_for_path (metadata_fn);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL);
if (info != NULL) {
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
gs_app_set_install_date (app, mtime);
}
/* this is faster than resolving */
gs_app_set_origin (app, xdg_app_installed_ref_get_origin (xref));
/* this is faster than xdg_app_installation_fetch_remote_size_sync() */
size_installed = xdg_app_installed_ref_get_installed_size (xref);
if (size_installed != 0)
gs_app_set_size_installed (app, size_installed);
}
static void
openoffice_cache_query_info_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
PdfLoadJob *job = user_data;
GError *error = NULL;
GFileInfo *info;
info = g_file_query_info_finish (G_FILE (source), res, &error);
if (error != NULL) {
/* create/invalidate cache */
pdf_load_job_openoffice_refresh_cache (job);
g_error_free (error);
return;
}
job->pdf_cache_mtime =
g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
if (job->original_file_mtime != job->pdf_cache_mtime) {
pdf_load_job_openoffice_refresh_cache (job);
} else {
job->from_old_cache = TRUE;
/* load the cached file */
pdf_load_job_from_pdf (job);
}
g_object_unref (info);
}
static void
g_zlib_compressor_set_gzheader (GZlibCompressor *compressor)
{
/* On win32, these functions were not exported before 1.2.4 */
#if !defined (G_OS_WIN32) || ZLIB_VERNUM >= 0x1240
const gchar *filename;
if (compressor->format != G_ZLIB_COMPRESSOR_FORMAT_GZIP ||
compressor->file_info == NULL)
return;
memset (&compressor->gzheader, 0, sizeof (gz_header));
compressor->gzheader.os = 0x03; /* Unix */
filename = g_file_info_get_name (compressor->file_info);
compressor->gzheader.name = (Bytef *) filename;
compressor->gzheader.name_max = filename ? strlen (filename) + 1 : 0;
compressor->gzheader.time =
(uLong) g_file_info_get_attribute_uint64 (compressor->file_info,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
if (deflateSetHeader (&compressor->zstream, &compressor->gzheader) != Z_OK)
g_warning ("unexpected zlib error: %s\n", compressor->zstream.msg);
#endif /* !G_OS_WIN32 || ZLIB >= 1.2.4 */
}
static gboolean
get_file_mtime (const char *file_uri, time_t* mtime)
{
GFile *file;
GFileInfo *info;
gboolean ret;
ret = FALSE;
*mtime = INVALID_MTIME;
file = g_file_new_for_uri (file_uri);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL);
if (info)
{
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
{
*mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
ret = TRUE;
}
g_object_unref (info);
}
g_object_unref (file);
return ret;
}
/**
* pk_offline_get_results_mtime:
* @error: A #GError or %NULL
*
* Gets the modification time of the prepared transaction.
*
* Return value: a unix time, or 0 for error.
*
* Since: 0.9.6
**/
guint64
pk_offline_get_results_mtime (GError **error)
{
g_autoptr(GError) error_local = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GFileInfo) info = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, 0);
file = g_file_new_for_path (PK_OFFLINE_RESULTS_FILENAME);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
NULL,
&error_local);
if (info == NULL) {
if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
g_set_error (error,
PK_OFFLINE_ERROR,
PK_OFFLINE_ERROR_NO_DATA,
"%s does not exist",
PK_OFFLINE_RESULTS_FILENAME);
return 0;
}
g_set_error (error,
PK_OFFLINE_ERROR,
PK_OFFLINE_ERROR_FAILED,
"Failed to read %s: %s",
PK_OFFLINE_RESULTS_FILENAME,
error_local->message);
return 0;
}
return g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
}
void GioLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
DeviceInfo& device_info = devices_[id];
GFile* root = g_mount_get_root(device_info.mount);
GError* error = NULL;
GFileInfo* info = g_file_query_filesystem_info(
root, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
device_info.filesystem_free = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
g_object_unref(info);
}
g_object_unref(root);
}
emit DeviceChanged(id);
}
static gboolean
xmms_gvfs_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error)
{
GError *err = NULL;
GFile *file;
GFileInfo *info;
GFileEnumerator *enumerator;
/* Same hack as in _init */
if (!g_ascii_strncasecmp (url, "file://", 7)) {
file = g_file_new_for_path (url+7);
} else {
file = g_file_new_for_uri (url);
}
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE,
G_FILE_QUERY_INFO_NONE,
NULL,
&err);
g_object_unref (file);
if (!enumerator) {
xmms_error_set (error, XMMS_ERROR_GENERIC, err->message);
return FALSE;
}
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL))) {
guint32 child_type, flags = 0;
guint64 child_size;
const gchar *child_name;
child_name = g_file_info_get_attribute_byte_string (info,
G_FILE_ATTRIBUTE_STANDARD_NAME);
child_type = g_file_info_get_attribute_uint32 (info,
G_FILE_ATTRIBUTE_STANDARD_TYPE);
child_size = g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_STANDARD_SIZE);
if (child_type & G_FILE_TYPE_DIRECTORY) {
flags |= XMMS_XFORM_BROWSE_FLAG_DIR;
}
xmms_xform_browse_add_entry (xform, child_name, flags);
if (~child_type & G_FILE_TYPE_DIRECTORY) {
xmms_xform_browse_add_entry_property_int (xform,
XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE,
child_size);
}
g_object_unref (info);
}
g_file_enumerator_close (enumerator, NULL, NULL);
return TRUE;
}
static int64_t
ddb_gvfs_getlength (DB_FILE *stream)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_val_if_fail (data != NULL, -1);
g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);
GError *error = NULL;
GFileInfo *info;
info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM(data->handle),
G_FILE_ATTRIBUTE_STANDARD_SIZE,
NULL, &error);
if (info == NULL)
{
g_warning ("Could not read stream info: %s", error->message);
g_error_free (error);
return -1;
}
gint64 size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
g_object_unref (info);
return size;
}
EphyWebApplication *
ephy_web_application_for_profile_directory (const char *profile_dir)
{
EphyWebApplication *app;
char *desktop_file_path;
const char *id;
GDesktopAppInfo *desktop_info;
const char *exec;
int argc;
char **argv;
GFile *file;
GFileInfo *file_info;
guint64 created;
GDate *date;
id = get_app_id_from_profile_directory (profile_dir);
if (!id)
return NULL;
app = g_new0 (EphyWebApplication, 1);
app->id = g_strdup (id);
app->desktop_file = get_app_desktop_filename (id);
desktop_file_path = g_build_filename (profile_dir, app->desktop_file, NULL);
desktop_info = g_desktop_app_info_new_from_filename (desktop_file_path);
if (!desktop_info) {
ephy_web_application_free (app);
g_free (desktop_file_path);
return NULL;
}
app->name = g_strdup (g_app_info_get_name (G_APP_INFO (desktop_info)));
app->icon_url = g_desktop_app_info_get_string (desktop_info, "Icon");
exec = g_app_info_get_commandline (G_APP_INFO (desktop_info));
if (g_shell_parse_argv (exec, &argc, &argv, NULL)) {
app->url = g_strdup (argv[argc - 1]);
g_strfreev (argv);
}
g_object_unref (desktop_info);
file = g_file_new_for_path (desktop_file_path);
/* FIXME: this should use TIME_CREATED but it does not seem to be working. */
file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL);
created = g_file_info_get_attribute_uint64 (file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
date = g_date_new ();
g_date_set_time_t (date, (time_t)created);
g_date_strftime (app->install_date, 127, "%x", date);
g_date_free (date);
g_object_unref (file);
g_object_unref (file_info);
g_free (desktop_file_path);
return app;
}
uint64_t getVolumeFreeSizeForPath(const char* path)
{
GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(path));
GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_filesystem_info(file.get(), G_FILE_ATTRIBUTE_FILESYSTEM_FREE, 0, 0));
if (!fileInfo)
return 0;
return g_file_info_get_attribute_uint64(fileInfo.get(), G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
}
static time_t
get_file_mtime (GFile * file)
{
time_t mtime;
GFileInfo * info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL);
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
g_object_unref (G_OBJECT (info));
return mtime;
}
static void
got_file_size_cb (GObject *source_object,
GAsyncResult *res,
gpointer userdata)
{
SwClientServiceCallClosure *closure = (SwClientServiceCallClosure *) userdata;
SwClientServicePrivate *priv = GET_PRIVATE (closure->service);
GFileInfo *info;
char *filename;
const char *signal;
info = g_file_query_info_finish (G_FILE (source_object), res, NULL);
if (info == NULL ||
g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) != G_FILE_TYPE_REGULAR) {
g_simple_async_report_error_in_idle (G_OBJECT (closure->service),
(GAsyncReadyCallback) closure->cb,
closure->userdata,
SW_CLIENT_SERVICE_ERROR,
0,
info ? "File to upload is not a regular file" :
"Could not get file size information for file");
if (info)
g_object_unref (info);
g_object_unref (closure->service);
g_hash_table_unref (closure->fields);
g_slice_free (SwClientServiceCallClosure, closure);
return;
}
closure->filesize = g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_STANDARD_SIZE);
g_object_unref (info);
signal = (closure->iface == PHOTO_UPLOAD_IFACE ? "PhotoUploadProgress" : "VideoUploadProgress");
dbus_g_proxy_connect_signal (priv->proxies[closure->iface], signal,
G_CALLBACK (_upload_file_progress_cb), closure, NULL);
filename = g_file_get_path (G_FILE (source_object));
if (closure->iface == PHOTO_UPLOAD_IFACE) {
org_gnome_libsocialweb_PhotoUpload_upload_photo_async (priv->proxies[PHOTO_UPLOAD_IFACE],
filename,
closure->fields,
_upload_file_cb,
closure);
} else {
org_gnome_libsocialweb_VideoUpload_upload_video_async (priv->proxies[VIDEO_UPLOAD_IFACE],
filename,
closure->fields,
_upload_file_cb,
closure);
}
g_hash_table_unref (closure->fields);
closure->fields = NULL;
g_free (filename);
}
static void
file_view_show_extended_data (AnjutaFileView* view, GtkTreeIter* iter)
{
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model);
gboolean is_dummy, is_dir;
GFile* file;
GFileInfo* file_info;
time_t time;
gchar* display;
gchar time_str[128];
AnjutaVcsStatus status;
gtk_tree_model_get (file_model, iter, COLUMN_DUMMY, &is_dummy,
COLUMN_IS_DIR, &is_dir, -1);
if (is_dummy || is_dir)
return;
gtk_tree_model_get (file_model, iter, COLUMN_FILE, &file,
COLUMN_STATUS, &status, -1);
file_info = g_file_query_info (file,
"standard::*,time::changed",
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
g_object_unref (file);
if (!file_info)
return;
time = g_file_info_get_attribute_uint64(file_info, "time::changed");
strftime(time_str, 127, "%x %X", localtime(&time));
if (get_status_string(status))
{
display = g_markup_printf_escaped("%s\n"
"<small><tt>%s</tt></small>\n"
"<small>%s</small>",
g_file_info_get_display_name(file_info),
time_str,
get_status_string(status));
}
else
{
display = g_markup_printf_escaped("%s\n"
"<small><tt>%s</tt></small>",
g_file_info_get_display_name(file_info),
time_str);
}
gtk_tree_store_set (GTK_TREE_STORE(file_model), iter,
COLUMN_DISPLAY, display,
-1);
g_object_unref (file_info);
g_free(display);
}
static gboolean
create_thumbnail (GIOSchedulerJob *job,
GCancellable *cancellable,
gpointer user_data)
{
GSimpleAsyncResult *result = user_data;
GFile *file = G_FILE (g_async_result_get_source_object (G_ASYNC_RESULT (result)));
GnomeDesktopThumbnailFactory *factory;
GFileInfo *info;
gchar *uri;
GdkPixbuf *pixbuf;
guint64 mtime;
uri = g_file_get_uri (file);
info = g_file_query_info (file, ATTRIBUTES_FOR_THUMBNAIL,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
/* we don't care about reporting errors here, just fail the
* thumbnail.
*/
if (info == NULL)
{
g_simple_async_result_set_op_res_gboolean (result, FALSE);
goto out;
}
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail
(factory,
uri, g_file_info_get_content_type (info));
if (pixbuf != NULL)
{
gnome_desktop_thumbnail_factory_save_thumbnail (factory, pixbuf,
uri, (time_t) mtime);
g_simple_async_result_set_op_res_gboolean (result, TRUE);
}
else
{
g_simple_async_result_set_op_res_gboolean (result, FALSE);
}
g_object_unref (info);
g_object_unref (file);
g_object_unref (factory);
g_clear_object (&pixbuf);
out:
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
return FALSE;
}
/**
* Returns the dates of a file
* @param fileinfo : a GFileInfo pointer obtained from an opened file
* (GFile *)
* @param meta : meta_data_t * structure that contains all meta data for
* the corresponding file.
* @returns "access_time changed_time modified_time" gchar *string
*/
gchar *get_dates_from_gfile(GFileInfo *fileinfo, meta_data_t *meta)
{
gchar *result = NULL;
if (fileinfo != NULL && meta != NULL)
{
meta->atime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_ACCESS);
meta->ctime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_CHANGED);
meta->mtime = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_TIME_MODIFIED);
result = g_strdup_printf("%" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT "", meta->atime, meta->ctime, meta->mtime);
}
else
{
result = g_strdup("");
}
return result;
}
static void
watchdir_file_update_mtime( struct watchdir_file * file )
{
GFile * gfile = g_file_new_for_path( file->filename );
GFileInfo * info = g_file_query_info( gfile, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL );
file->mtime = g_file_info_get_attribute_uint64( info, G_FILE_ATTRIBUTE_TIME_MODIFIED );
g_object_unref( G_OBJECT( info ) );
g_object_unref( G_OBJECT( gfile ) );
}
/* local_db_needs_update function returns TRUE on success and FALSE on failure.
* It sets the parameter needs_update to TRUE if the local database needs
* to be updated.
*/
static gboolean
local_db_needs_update (SoupSession *session,
const char *db_uri,
GFile *db_local,
gboolean *needs_update,
GError **error)
{
GFileInfo *db_local_info;
SoupMessage *msg;
SoupDate *date;
const gchar *db_time_str;
guint64 db_time;
guint64 db_local_time;
guint status_code;
if (g_file_query_exists (db_local, NULL) == FALSE) {
*needs_update = TRUE;
return TRUE;
}
msg = soup_message_new ("HEAD", db_uri);
status_code = soup_session_send_message (session, msg);
if (status_code != SOUP_STATUS_OK) {
g_set_error_literal (error,
SOUP_HTTP_ERROR,
status_code,
msg->reason_phrase);
return FALSE;
}
db_time_str = soup_message_headers_get_one (msg->response_headers, "Last-Modified");
date = soup_date_new_from_string (db_time_str);
db_time = (guint64) soup_date_to_time_t (date);
soup_date_free (date);
g_object_unref (msg);
db_local_info = g_file_query_info (db_local,
"time::modified",
G_FILE_QUERY_INFO_NONE,
NULL,
error);
if (!db_local_info)
return FALSE;
db_local_time = g_file_info_get_attribute_uint64 (db_local_info, "time::modified");
if (db_time <= db_local_time)
*needs_update = FALSE;
else
*needs_update = TRUE;
g_object_unref (db_local_info);
return TRUE;
}
static EogThumbData*
eog_thumb_data_new (GFile *file, GError **error)
{
EogThumbData *data;
GFileInfo *file_info;
GError *ioerror = NULL;
g_return_val_if_fail (file != NULL, NULL);
g_return_val_if_fail (error != NULL && *error == NULL, NULL);
data = g_slice_new0 (EogThumbData);
data->uri_str = g_file_get_uri (file);
data->thumb_path = gnome_desktop_thumbnail_path_for_uri (data->uri_str, GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED ","
G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
0, NULL, &ioerror);
if (file_info == NULL)
{
set_vfs_error (error, ioerror);
g_clear_error (&ioerror);
}
if (*error == NULL) {
/* if available, copy data */
data->mtime = g_file_info_get_attribute_uint64 (file_info,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
data->mime_type = g_strdup (g_file_info_get_content_type (file_info));
data->thumb_exists = (g_file_info_get_attribute_byte_string (file_info,
G_FILE_ATTRIBUTE_THUMBNAIL_PATH) != NULL);
data->failed_thumb_exists = g_file_info_get_attribute_boolean (file_info,
G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
data->can_read = TRUE;
if (g_file_info_has_attribute (file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
data->can_read = g_file_info_get_attribute_boolean (file_info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
}
}
else {
eog_thumb_data_free (data);
data = NULL;
g_clear_error (&ioerror);
}
g_object_unref (file_info);
return data;
}
guint64
rstto_file_get_modified_time ( RsttoFile *r_file )
{
guint64 time_ = 0;
GFileInfo *file_info = g_file_query_info (r_file->priv->file, "time::modified", 0, NULL, NULL);
time_ = g_file_info_get_attribute_uint64 ( file_info, "time::modified" );
g_object_unref (file_info);
return time_;
}
static gboolean
file_is_loadable( GFile *file )
{
static const gchar *thisfn = "na_core_utils_file_is_loadable";
GError *error;
GFileInfo *info;
guint64 size;
GFileType type;
gboolean isok;
GFile *target_file;
error = NULL;
isok = FALSE;
info = g_file_query_info( file,
G_FILE_ATTRIBUTE_STANDARD_SIZE "," G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, &error );
if( !info ){
if( error ){
g_debug( "%s: %s", thisfn, error->message );
g_error_free( error );
}
} else {
size = g_file_info_get_attribute_uint64( info, G_FILE_ATTRIBUTE_STANDARD_SIZE );
g_debug( "%s: size=%lu", thisfn, ( unsigned long ) size );
isok = ( size >= SIZE_MIN && size <= SIZE_MAX );
}
if( isok ){
type = g_file_info_get_file_type( info );
g_debug( "%s: type=%u", thisfn, ( unsigned ) type );
if( type != G_FILE_TYPE_REGULAR ){
isok = FALSE;
if( type == G_FILE_TYPE_SYMBOLIC_LINK ){
const char *target = g_file_info_get_symlink_target( info );
if( target && strlen( target )){
target_file = g_file_resolve_relative_path( file, target );
if( target_file ){
isok = file_is_loadable( target_file );
g_object_unref( target_file );
}
}
}
}
}
g_object_unref( info );
return( isok );
}
static gboolean
add_single_file_from_info (BgPicturesSource *bg_source,
GFile *file,
GFileInfo *info,
GtkTreeRowReference **ret_row_ref)
{
const gchar *content_type;
guint64 mtime;
content_type = g_file_info_get_content_type (info);
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
return add_single_file (bg_source, file, content_type, mtime, ret_row_ref);
}
/**
* Returns the inode of the file fileinfo
* @param fileinfo : a GFileInfo pointer obtained from an opened file
* (GFile *)
* @param[out] meta : meta_data_t * structure that contains all meta data
* for the corresponding file (populated here with
* inode number.
* @returns the inode file.
*/
guint64 get_inode_from_gfile(GFileInfo *fileinfo, meta_data_t *meta)
{
guint64 inode = 0;
if (fileinfo != NULL && meta != NULL)
{
inode = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_UNIX_INODE);
meta->inode = inode;
}
return inode;
}
void vfs_backend_get_file_properties (const gchar *cURI, guint64 *iSize, time_t *iLastModificationTime, gchar **cMimeType, int *iUID, int *iGID, int *iPermissionsMask)
{
g_return_if_fail (cURI != NULL);
GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
GError *erreur = NULL;
const gchar *cQuery = G_FILE_ATTRIBUTE_STANDARD_SIZE","
G_FILE_ATTRIBUTE_TIME_MODIFIED","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","
G_FILE_ATTRIBUTE_UNIX_UID","
G_FILE_ATTRIBUTE_UNIX_GID","
G_FILE_ATTRIBUTE_ACCESS_CAN_READ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE","
G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE;
GFileInfo *pFileInfo = g_file_query_info (pFile,
cQuery,
G_FILE_QUERY_INFO_NONE, /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
NULL,
&erreur);
if (erreur != NULL)
{
cd_warning ("Attention : couldn't get file properties for '%s' [%s]", cURI, erreur->message);
g_error_free (erreur);
}
*iSize = g_file_info_get_attribute_uint64 (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_SIZE);
*iLastModificationTime = (time_t) g_file_info_get_attribute_uint64 (pFileInfo, G_FILE_ATTRIBUTE_TIME_MODIFIED);
*cMimeType = g_file_info_get_attribute_as_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
*iUID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_UNIX_UID);
*iGID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_UNIX_GID);
int r = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
int w = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
int x = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE);
*iPermissionsMask = r * 8 * 8 + w * 8 + x;
g_object_unref (pFileInfo);
g_object_unref (pFile);
}
/**
* Returns the file size from a GFile * file
* @param file is the GFile from which we want the size.
* @returns a guint64 that represents the file size or 0.
*/
guint64 get_file_size(GFile *file)
{
GError *error = NULL;
GFileInfo *fileinfo = NULL;
guint64 size = 0;
if (file != NULL)
{
fileinfo = g_file_query_info(file, "*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &error);
size = g_file_info_get_attribute_uint64(fileinfo, G_FILE_ATTRIBUTE_STANDARD_SIZE);
free_object(fileinfo);
}
return size;
}
static const gchar *
xfdesktop_volume_icon_peek_tooltip(XfdesktopIcon *icon)
{
XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon);
GFileInfo *fs_info = xfdesktop_file_icon_peek_filesystem_info(XFDESKTOP_FILE_ICON(icon));
GFile *file = xfdesktop_file_icon_peek_file(XFDESKTOP_FILE_ICON(icon));
if(!volume_icon->priv->tooltip) {
guint64 size, free_space;
gchar *mount_point = NULL, *size_string = NULL, *free_space_string = NULL;
if(file && fs_info) {
mount_point = g_file_get_parse_name(file);
size = g_file_info_get_attribute_uint64(fs_info,
G_FILE_ATTRIBUTE_FILESYSTEM_SIZE);
free_space = g_file_info_get_attribute_uint64(fs_info,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
size_string = g_format_size(size);
free_space_string = g_format_size(free_space);
volume_icon->priv->tooltip =
g_strdup_printf(_("Removable Volume\nMounted in \"%s\"\n%s left (%s total)"),
mount_point, free_space_string, size_string);
g_free(free_space_string);
g_free(size_string);
g_free(mount_point);
} else {
volume_icon->priv->tooltip = g_strdup(_("Removable Volume\nNot mounted yet"));
}
}
return volume_icon->priv->tooltip;
}
static void
create_thumbnail (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = G_FILE (source_object);
GnomeDesktopThumbnailFactory *factory = NULL;
GError *error = NULL;
GFileInfo *info = NULL;
gchar *uri = NULL;
GdkPixbuf *pixbuf = NULL;
guint64 mtime;
uri = g_file_get_uri (file);
info = g_file_query_info (file, ATTRIBUTES_FOR_THUMBNAIL,
G_FILE_QUERY_INFO_NONE,
NULL, &error);
if (info == NULL)
{
g_task_return_error (task, error);
goto out;
}
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE);
pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail
(factory,
uri, g_file_info_get_content_type (info));
if (pixbuf == NULL)
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "GnomeDesktopThumbnailFactory failed");
goto out;
}
gnome_desktop_thumbnail_factory_save_thumbnail (factory, pixbuf, uri, (time_t) mtime);
g_task_return_boolean (task, TRUE);
out:
g_clear_object (&info);
g_clear_object (&factory);
g_clear_object (&pixbuf);
g_free (uri);
}
