GVariant *
ostree_zlib_file_header_new (GFileInfo *file_info,
GVariant *xattrs)
{
guint64 size;
guint32 uid;
guint32 gid;
guint32 mode;
guint32 rdev;
const char *symlink_target;
GVariant *ret;
ot_lvariant GVariant *tmp_xattrs = NULL;
size = g_file_info_get_size (file_info);
uid = g_file_info_get_attribute_uint32 (file_info, "unix::uid");
gid = g_file_info_get_attribute_uint32 (file_info, "unix::gid");
mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
rdev = g_file_info_get_attribute_uint32 (file_info, "unix::rdev");
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_SYMBOLIC_LINK)
symlink_target = g_file_info_get_symlink_target (file_info);
else
symlink_target = "";
if (xattrs == NULL)
tmp_xattrs = g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0));
ret = g_variant_new ("(tuuuus@a(ayay))",
GUINT64_TO_BE (size), GUINT32_TO_BE (uid),
GUINT32_TO_BE (gid), GUINT32_TO_BE (mode), GUINT32_TO_BE (rdev),
symlink_target, xattrs ? xattrs : tmp_xattrs);
g_variant_ref_sink (ret);
return ret;
}
/**
* 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("");
}
}
}
GVariant *
ostree_create_directory_metadata (GFileInfo *dir_info,
GVariant *xattrs)
{
GVariant *ret_metadata = NULL;
ret_metadata = g_variant_new ("(uuu@a(ayay))",
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::uid")),
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::gid")),
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::mode")),
xattrs ? xattrs : g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0));
g_variant_ref_sink (ret_metadata);
return ret_metadata;
}
gboolean update_trash(gpointer user_data)
{
if(fm_config->use_trash)
{
GFile* gf = g_file_new_for_uri("trash:///");
GFileInfo* inf = g_file_query_info(gf, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, 0, NULL, NULL);
g_object_unref(gf);
if(inf)
{
FmIcon* icon;
const char* icon_name;
PlaceItem* item;
GdkPixbuf* pix;
guint32 n = g_file_info_get_attribute_uint32(inf, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
g_object_unref(inf);
icon_name = n > 0 ? "user-trash-full" : "user-trash";
icon = fm_icon_from_name(icon_name);
gtk_tree_model_get(GTK_TREE_MODEL(model), &trash_it, COL_INFO, &item, -1);
if(item->icon)
fm_icon_unref(item->icon);
item->icon = icon;
/* update the icon */
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &trash_it, COL_ICON, pix, -1);
g_object_unref(pix);
}
}
return FALSE;
}
static OstreeRepoCommitFilterResult
commit_filter (OstreeRepo *repo,
const char *path,
GFileInfo *file_info,
gpointer user_data)
{
guint current_mode;
/* No user info */
g_file_info_set_attribute_uint32 (file_info, "unix::uid", 0);
g_file_info_set_attribute_uint32 (file_info, "unix::gid", 0);
/* No setuid */
current_mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
g_file_info_set_attribute_uint32 (file_info, "unix::mode", current_mode & ~07000);
if (g_str_equal (path, "/") ||
g_str_equal (path, "/metadata") ||
g_str_has_prefix (path, "/files") ||
g_str_has_prefix (path, "/export"))
{
g_debug ("commit filter, allow: %s", path);
return OSTREE_REPO_COMMIT_FILTER_ALLOW;
}
else
{
g_debug ("commit filter, skip: %s", path);
return OSTREE_REPO_COMMIT_FILTER_SKIP;
}
}
static gboolean is_directory(const gchar* filename)
{
GFile* file;
GFileType type;
GFileInfo *file_info;
// FIXME check if filename can only be local file here
file = g_file_new_for_path(filename);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (file_info == NULL)
{
g_object_unref (G_OBJECT (file));
return FALSE;
}
type = g_file_info_get_attribute_uint32 (file_info,
G_FILE_ATTRIBUTE_STANDARD_TYPE);
g_object_unref(G_OBJECT(file_info));
g_object_unref(G_OBJECT(file));
return type == G_FILE_TYPE_DIRECTORY ? TRUE : FALSE;
}
static void
trash_applet_monitor_changed (TrashApplet *applet)
{
GError *error = NULL;
GFileInfo *info;
GIcon *icon;
gint items;
info = g_file_query_info (applet->trash,
G_FILE_ATTRIBUTE_STANDARD_ICON","
G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT,
0, NULL, &error);
if (!info)
{
g_critical ("could not query trash:/: '%s'", error->message);
g_error_free (error);
return;
}
icon = g_file_info_get_icon (info);
items = g_file_info_get_attribute_uint32 (info,
G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
if (!g_icon_equal (icon, applet->icon))
{
/* note: the size is meaningless here,
* since we do set_pixel_size() later
*/
gtk_image_set_from_gicon (GTK_IMAGE (applet->image),
icon, GTK_ICON_SIZE_MENU);
if (applet->icon)
g_object_unref (applet->icon);
applet->icon = g_object_ref (icon);
}
if (items != applet->items)
{
if (items)
{
char *text;
text = g_strdup_printf (ngettext ("%d Item in Trash",
"%d Items in Trash",
items), items);
gtk_widget_set_tooltip_text (GTK_WIDGET (applet), text);
g_free (text);
}
else
gtk_widget_set_tooltip_text (GTK_WIDGET (applet),
_("No Items in Trash"));
applet->items = items;
}
g_object_unref (info);
}
/*int*/
main (int argc, char **argv)
{
GFile *file;
GFileInfo *info;
GCancellable *cancel;
time_t time;
GError *error = NULL;
g_type_init();
cancel = g_cancellable_new ();
file = g_file_new_for_uri ("file:///home/gabriel/Imagens/jazzradio1.jpg");
info = g_file_query_info (file, "standard::*", G_FILE_QUERY_INFO_NONE,
cancel, &error);
guint32 xtime;
xtime = g_file_info_get_attribute_uint32 (info, "time::created-usec");
GDate *date;
date = g_date_new_julian (xtime);
g_print ("Dia: %d\n=========", (int) g_date_get_month(date));
if (error)
g_printerr ("FUDEU: %s\n", error->message);
g_print ("O tamanho do arquivo eh: %d", (int) g_file_info_get_size (info));
return 0;
}
static OstreeRepoCommitFilterResult
commit_filter (OstreeRepo *self,
const char *path,
GFileInfo *file_info,
gpointer user_data)
{
GHashTable *mode_adds = user_data;
gpointer value;
if (opt_owner_uid >= 0)
g_file_info_set_attribute_uint32 (file_info, "unix::uid", opt_owner_uid);
if (opt_owner_gid >= 0)
g_file_info_set_attribute_uint32 (file_info, "unix::gid", opt_owner_gid);
if (mode_adds && g_hash_table_lookup_extended (mode_adds, path, NULL, &value))
{
guint current_mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
guint mode_add = GPOINTER_TO_UINT (value);
g_file_info_set_attribute_uint32 (file_info, "unix::mode",
current_mode | mode_add);
g_hash_table_remove (mode_adds, path);
}
return OSTREE_REPO_COMMIT_FILTER_ALLOW;
}
static gboolean
check_file_is_directory (GFile *file, GError **error)
{
GFileInfo *info;
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, error);
if (*error == NULL) {
/* check it's a directory */
GFileType filetype;
gboolean ret = TRUE;
filetype = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
if (filetype != G_FILE_TYPE_DIRECTORY) {
/* um.. */
ret = FALSE;
}
g_object_unref (info);
return ret;
}
if (g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
g_clear_error (error);
}
return FALSE;
}
static OstreeRepoCommitFilterResult
commit_filter (OstreeRepo *repo,
const char *path,
GFileInfo *file_info,
CommitData *commit_data)
{
guint mode;
/* No user info */
g_file_info_set_attribute_uint32 (file_info, "unix::uid", 0);
g_file_info_set_attribute_uint32 (file_info, "unix::gid", 0);
mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
/* No setuid */
mode = mode & ~07000;
/* All files readable */
mode = mode | 0444;
g_file_info_set_attribute_uint32 (file_info, "unix::mode", mode);
if (matches_patterns (commit_data->exclude, path) &&
!matches_patterns (commit_data->include, path))
{
g_debug ("Excluding %s", path);
return OSTREE_REPO_COMMIT_FILTER_SKIP;
}
return OSTREE_REPO_COMMIT_FILTER_ALLOW;
}
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 gboolean
uri_recurse_func (GFile *file, GFileInfo *info, RhythmDBImportJob *job)
{
RhythmDBEntry *entry;
char *uri;
if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) == G_FILE_TYPE_DIRECTORY) {
return TRUE;
}
if (g_cancellable_is_cancelled (job->priv->cancel))
return FALSE;
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK)) {
GFile *r;
r = rb_file_resolve_symlink (file, NULL);
if (r != NULL) {
uri = g_file_get_uri (r);
g_object_unref (r);
} else {
return FALSE;
}
} else {
uri = g_file_get_uri (file);
}
/* if it's not already in the db, add it to the list of things to process */
entry = rhythmdb_entry_lookup_by_location (job->priv->db, uri);
if (entry == NULL) {
rb_debug ("waiting for entry %s", uri);
g_mutex_lock (&job->priv->lock);
job->priv->total++;
g_queue_push_tail (job->priv->outstanding, g_strdup (uri));
if (job->priv->status_changed_id == 0) {
job->priv->status_changed_id = g_idle_add ((GSourceFunc) emit_status_changed, job);
}
maybe_start_more (job);
g_mutex_unlock (&job->priv->lock);
} else {
/* skip it if it's a different entry type */
RhythmDBEntryType *et;
et = rhythmdb_entry_get_entry_type (entry);
if (et == job->priv->entry_type ||
et == job->priv->ignore_type ||
et == job->priv->error_type) {
rhythmdb_add_uri_with_types (job->priv->db,
uri,
job->priv->entry_type,
job->priv->ignore_type,
job->priv->error_type);
}
}
g_free (uri);
return TRUE;
}
/**
* ostree_repo_checkout_gc:
* @self: Repo
* @cancellable: Cancellable
* @error: Error
*
* Call this after finishing a succession of checkout operations; it
* will delete any currently-unused uncompressed objects from the
* cache.
*/
gboolean
ostree_repo_checkout_gc (OstreeRepo *self,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
g_autoptr(GHashTable) to_clean_dirs = NULL;
GHashTableIter iter;
gpointer key, value;
g_mutex_lock (&self->cache_lock);
to_clean_dirs = self->updated_uncompressed_dirs;
self->updated_uncompressed_dirs = g_hash_table_new (NULL, NULL);
g_mutex_unlock (&self->cache_lock);
if (to_clean_dirs)
g_hash_table_iter_init (&iter, to_clean_dirs);
while (to_clean_dirs && g_hash_table_iter_next (&iter, &key, &value))
{
g_autoptr(GFile) objdir = NULL;
g_autoptr(GFileEnumerator) enumerator = NULL;
g_autofree char *objdir_name = NULL;
objdir_name = g_strdup_printf ("%02x", GPOINTER_TO_UINT (key));
objdir = g_file_get_child (self->uncompressed_objects_dir, objdir_name);
enumerator = g_file_enumerate_children (objdir, "standard::name,standard::type,unix::inode,unix::nlink",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable,
error);
if (!enumerator)
goto out;
while (TRUE)
{
GFileInfo *file_info;
guint32 nlinks;
if (!gs_file_enumerator_iterate (enumerator, &file_info, NULL,
cancellable, error))
goto out;
if (file_info == NULL)
break;
nlinks = g_file_info_get_attribute_uint32 (file_info, "unix::nlink");
if (nlinks == 1)
{
g_autoptr(GFile) objpath = NULL;
objpath = g_file_get_child (objdir, g_file_info_get_name (file_info));
if (!gs_file_unlink (objpath, cancellable, error))
goto out;
}
}
}
ret = TRUE;
out:
return ret;
}
void trash_changed()
{
GFileInfo* info = g_file_query_info(_trash_can, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, G_FILE_QUERY_INFO_NONE, NULL, NULL);
int count = g_file_info_get_attribute_uint32(info, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
g_object_unref(info);
JSObjectRef value = json_create();
json_append_number(value, "value", count);
js_post_message("trash_count_changed", value);
}
double fileops_get_trash_count()
{
GFile* _trash_can = fileops_get_trash_entry ();
GFileInfo* info = g_file_query_info(_trash_can, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, G_FILE_QUERY_INFO_NONE, NULL, NULL);
double count = g_file_info_get_attribute_uint32(info, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
g_object_unref(info);
g_object_unref(_trash_can);
return count;
}
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 gint
mode_from_flags_or_info (GFileCreateFlags flags,
GFileInfo *reference_info)
{
if (flags & G_FILE_CREATE_PRIVATE)
return 0600;
else if (reference_info && g_file_info_has_attribute (reference_info, "unix::mode"))
return g_file_info_get_attribute_uint32 (reference_info, "unix::mode") & (~S_IFMT);
else
return 0666;
}
double fileops_get_trash_count()
{
GFile* _trash_can = fileops_get_trash_entry ();
GFileInfo* info = g_file_query_info(_trash_can, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, G_FILE_QUERY_INFO_NONE, NULL, NULL);
double count = 0;
if (info != NULL) { // info maybe equal NULL when use xinit run desktop
count = g_file_info_get_attribute_uint32(info, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
g_object_unref(info);
}
g_object_unref(_trash_can);
return count;
}
/**
* Returns the username of the owner 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 owner,
* group, uid and gid.
* @returns the "user:group uid:gid" of the file or an empty string if an
* error occurs
*/
gchar *get_username_owner_from_gfile(GFileInfo *fileinfo, meta_data_t *meta)
{
gchar *result = NULL;
if (fileinfo != NULL && meta != NULL)
{
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);
result = g_strdup_printf("%s:%s %d:%d", meta->owner, meta->group, meta->uid, meta->gid);
}
else
{
result = g_strdup("");
}
return result;
}
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);
}
guint32
tracker_process_get_uid_for_pid (const gchar *pid_as_string,
gchar **filename)
{
GFile *f;
GFileInfo *info;
GError *error = NULL;
gchar *fn;
gchar *proc_dir_name;
guint uid;
proc_dir_name = g_build_filename ("/proc", pid_as_string, NULL);
#ifdef __sun /* Solaris */
fn = g_build_filename (proc_dir_name, "psinfo", NULL);
#else
fn = g_build_filename (proc_dir_name, "cmdline", NULL);
#endif
f = g_file_new_for_path (proc_dir_name);
info = g_file_query_info (f,
G_FILE_ATTRIBUTE_UNIX_UID,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
&error);
if (error) {
g_printerr ("%s '%s', %s", _("Could not stat() file"), proc_dir_name, error->message);
g_error_free (error);
uid = 0;
} else {
uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID);
g_object_unref (info);
}
g_free (proc_dir_name);
if (filename) {
*filename = fn;
} else {
g_free (fn);
}
g_object_unref (f);
return uid;
}
static gboolean
add_watch (const gchar *cmdline,
WatchType watch_type,
GFileMonitorFlags flags,
gboolean connect_handler)
{
GFileMonitor *monitor = NULL;
GError *error = NULL;
GFile *file;
file = g_file_new_for_commandline_arg (cmdline);
if (watch_type == WATCH_AUTO)
{
GFileInfo *info;
guint32 type;
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, &error);
if (!info)
goto err;
type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
watch_type = (type == G_FILE_TYPE_DIRECTORY) ? WATCH_DIR : WATCH_FILE;
}
if (watch_type == WATCH_DIR)
monitor = g_file_monitor_directory (file, flags, NULL, &error);
else
monitor = g_file_monitor (file, flags, NULL, &error);
if (!monitor)
goto err;
if (connect_handler)
g_signal_connect (monitor, "changed", G_CALLBACK (watch_callback), g_strdup (cmdline));
monitor = NULL; /* leak */
return TRUE;
err:
g_printerr ("error: %s: %s", cmdline, error->message);
g_error_free (error);
return FALSE;
}
/**
* Get unix mode 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 a newly allocated string with file mode in decimal
* representation.
*/
gchar *get_file_mode_from_gfile(GFileInfo *fileinfo, meta_data_t *meta)
{
gchar *result = NULL;
if (fileinfo != NULL)
{
meta->mode = g_file_info_get_attribute_uint32(fileinfo, G_FILE_ATTRIBUTE_UNIX_MODE);
result = g_strdup_printf("%d", meta->mode);
}
else
{
result = g_strdup("");
}
return result;
}
gboolean
rb_uri_is_directory (const char *uri)
{
GFile *f;
GFileInfo *fi;
GFileType ftype;
f = g_file_new_for_uri (uri);
fi = g_file_query_info (f, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, NULL);
g_object_unref (f);
if (fi == NULL) {
/* ? */
return FALSE;
}
ftype = g_file_info_get_attribute_uint32 (fi, G_FILE_ATTRIBUTE_STANDARD_TYPE);
g_object_unref (fi);
return (ftype == G_FILE_TYPE_DIRECTORY);
}
static gboolean
should_purge_file (GFile *file,
GCancellable *cancellable,
GDateTime *old)
{
GFileInfo *info;
GDateTime *date;
gboolean should_purge;
should_purge = FALSE;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_TRASH_DELETION_DATE ","
G_FILE_ATTRIBUTE_UNIX_UID ","
G_FILE_ATTRIBUTE_TIME_CHANGED,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable,
NULL);
date = g_file_info_get_deletion_date (info);
if (date == NULL) {
guint uid;
guint64 ctime;
uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID);
if (uid != getuid ()) {
should_purge = FALSE;
goto out;
}
ctime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED);
date = g_date_time_new_from_unix_local ((gint64) ctime);
}
should_purge = g_date_time_difference (old, date) >= 0;
g_date_time_unref (date);
out:
g_object_unref (info);
return should_purge;
}
static OstreeRepoCommitFilterResult
commit_filter (OstreeRepo *repo,
const char *path,
GFileInfo *file_info,
CommitData *commit_data)
{
guint mode;
/* No user info */
g_file_info_set_attribute_uint32 (file_info, "unix::uid", 0);
g_file_info_set_attribute_uint32 (file_info, "unix::gid", 0);
/* In flatpak, there is no real reason for files to have different
* permissions based on the group or user really, everything is
* always used readonly for everyone. Having things be writeable
* for anyone but the user just causes risks for the system-installed
* case. So, we canonicalize the mode to writable only by the user,
* readable to all, and executable for all for directories and
* files that the user can execute.
*/
mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY)
mode = 0755 | S_IFDIR;
else if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_REGULAR)
{
/* If use can execute, make executable by all */
if (mode & S_IXUSR)
mode = 0755 | S_IFREG;
else /* otherwise executable by none */
mode = 0644 | S_IFREG;
}
g_file_info_set_attribute_uint32 (file_info, "unix::mode", mode);
if (matches_patterns (commit_data->exclude, path) &&
!matches_patterns (commit_data->include, path))
{
g_debug ("Excluding %s", path);
return OSTREE_REPO_COMMIT_FILTER_SKIP;
}
return OSTREE_REPO_COMMIT_FILTER_ALLOW;
}
PRIVATE
void _add_monitor_directory(GFile* f)
{
g_assert(_inotify_fd != -1);
GFileInfo* info = g_file_query_info(f, "standard::type", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL);
if (info == NULL) return; //temp file may cause this like downloading file or compressing file
GFileType type = g_file_info_get_attribute_uint32(info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
g_assert(info != NULL);
if (g_file_info_get_is_symlink(info)) {
GFile* maybe_real_target = g_file_new_for_uri(g_file_info_get_symlink_target(info));
_add_monitor_directory(maybe_real_target);
g_object_unref(maybe_real_target);
} else if (type == G_FILE_TYPE_DIRECTORY) {
char* path = g_file_get_path(f);
int watch = inotify_add_watch(_inotify_fd, path, IN_CREATE | IN_DELETE | IN_MODIFY | IN_MOVED_FROM | IN_MOVED_TO | IN_ATTRIB);
g_free(path);
g_hash_table_insert(_monitor_table, GINT_TO_POINTER(watch), g_object_ref(f));
}
g_object_unref(info);
}
static void
_panel_key_file_make_executable (const gchar *path)
{
GFile *file;
GFileInfo *info;
guint32 current_perms;
guint32 new_perms;
file = g_file_new_for_path (path);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE","
G_FILE_ATTRIBUTE_UNIX_MODE,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
NULL);
if (info == NULL) {
g_warning ("Cannot mark %s executable", path);
g_object_unref (file);
return;
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_MODE)) {
current_perms = g_file_info_get_attribute_uint32 (info,
G_FILE_ATTRIBUTE_UNIX_MODE);
new_perms = current_perms | S_IXGRP | S_IXUSR | S_IXOTH;
if ((current_perms != new_perms) &&
!g_file_set_attribute_uint32 (file,
G_FILE_ATTRIBUTE_UNIX_MODE,
new_perms,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL))
g_warning ("Cannot mark %s executable", path);
}
g_object_unref (info);
g_object_unref (file);
}
static inline guint32
get_uid_for_pid (const gchar *pid_as_string,
gchar **filename)
{
GFile *f;
GFileInfo *info;
GError *error = NULL;
gchar *fn;
guint uid;
fn = g_build_filename ("/proc", pid_as_string, "cmdline", NULL);
f = g_file_new_for_path (fn);
info = g_file_query_info (f,
G_FILE_ATTRIBUTE_UNIX_UID,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
&error);
if (error) {
g_printerr ("Could not stat() file:'%s', %s", fn, error->message);
g_error_free (error);
uid = 0;
} else {
uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID);
g_object_unref (info);
}
if (filename) {
*filename = fn;
} else {
g_free (fn);
}
g_object_unref (f);
return uid;
}
