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; }