1	/* GIO - GLib Input, Output and Streaming Library
2	*
3	* Copyright (C) 2006-2007 Red Hat, Inc.
4	* Copyright © 2007 Ryan Lortie
5	*
6	* This library is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 of the License, or (at your option) any later version.
10	*
11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General
17	* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18	*
19	* Author: Alexander Larsson <alexl@redhat.com>
20	* Ryan Lortie <desrt@desrt.ca>
21	*/
22
23	/* Prelude {{{1 */
24
25	#include "config.h"
26
27	/* For the #GDesktopAppInfoLookup macros; since macro deprecation is implemented
28	* in the preprocessor, we need to define this before including glib.h*/
29	#ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
30	#define GLIB_DISABLE_DEPRECATION_WARNINGS
31	#endif
32
33	#include <errno.h>
34	#include <string.h>
35	#include <unistd.h>
36
37	#ifdef HAVE_CRT_EXTERNS_H
38	#include <crt_externs.h>
39	#endif
40
41	#include "gcontenttypeprivate.h"
42	#include "gdesktopappinfo.h"
43	#ifdef G_OS_UNIX
44	#include "glib-unix.h"
45	#endif
46	#include "gfile.h"
47	#include "gioerror.h"
48	#include "gthemedicon.h"
49	#include "gfileicon.h"
50	#include <glib/gstdio.h>
51	#include "glibintl.h"
52	#include "giomodule-priv.h"
53	#include "gappinfo.h"
54	#include "gappinfoprivate.h"
55	#include "glocalfilemonitor.h"
56
57	#ifdef G_OS_UNIX
58	#include "gdocumentportal.h"
59	#endif
60
61	/**
62	* SECTION:gdesktopappinfo
63	* @title: GDesktopAppInfo
64	* @short_description: Application information from desktop files
65	* @include: gio/gdesktopappinfo.h
66	*
67	* #GDesktopAppInfo is an implementation of #GAppInfo based on
68	* desktop files.
69	*
70	* Note that `<gio/gdesktopappinfo.h>` belongs to the UNIX-specific
71	* GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
72	* file when using it.
73	*/
74
75	#define DEFAULT_APPLICATIONS_GROUP "Default Applications"
76	#define ADDED_ASSOCIATIONS_GROUP "Added Associations"
77	#define REMOVED_ASSOCIATIONS_GROUP "Removed Associations"
78	#define MIME_CACHE_GROUP "MIME Cache"
79	#define GENERIC_NAME_KEY "GenericName"
80	#define FULL_NAME_KEY "X-GNOME-FullName"
81	#define KEYWORDS_KEY "Keywords"
82	#define STARTUP_WM_CLASS_KEY "StartupWMClass"
83
84	enum {
85	PROP_0,
86	PROP_FILENAME
87	};
88
89	static void g_desktop_app_info_iface_init (GAppInfoIface *iface);
90	static gboolean g_desktop_app_info_ensure_saved (GDesktopAppInfo *info,
91	GError **error);
92
93	/**
94	* GDesktopAppInfo:
95	*
96	* Information about an installed application from a desktop file.
97	*/
98	struct _GDesktopAppInfo
99	{
100	GObject parent_instance;
101
102	char *desktop_id;
103	char *filename;
104	char *app_id;
105
106	GKeyFile *keyfile;
107
108	char *name;
109	char *generic_name;
110	char *fullname;
111	char *comment;
112	char *icon_name;
113	GIcon *icon;
114	char **keywords;
115	char **only_show_in;
116	char **not_show_in;
117	char *try_exec;
118	char *exec;
119	char *binary;
120	char *path;
121	char *categories;
122	char *startup_wm_class;
123	char **mime_types;
124	char **actions;
125
126	guint nodisplay : 1;
127	guint hidden : 1;
128	guint terminal : 1;
129	guint startup_notify : 1;
130	guint no_fuse : 1;
131	};
132
133	typedef enum {
134	UPDATE_MIME_NONE = 1 << 0,
135	UPDATE_MIME_SET_DEFAULT = 1 << 1,
136	UPDATE_MIME_SET_NON_DEFAULT = 1 << 2,
137	UPDATE_MIME_REMOVE = 1 << 3,
138	UPDATE_MIME_SET_LAST_USED = 1 << 4,
139	} UpdateMimeFlags;
140
141	G_DEFINE_TYPE_WITH_CODE (GDesktopAppInfo, g_desktop_app_info, G_TYPE_OBJECT,
142	G_IMPLEMENT_INTERFACE (G_TYPE_APP_INFO, g_desktop_app_info_iface_init))
143
144	/* DesktopFileDir implementation {{{1 */
145
146	typedef struct
147	{
148	gatomicrefcount ref_count;
149	gchar *path;
150	gchar *alternatively_watching;
151	gboolean is_config;
152	gboolean is_setup;
153	GFileMonitor *monitor;
154	GHashTable *app_names;
155	GHashTable *mime_tweaks;
156	GHashTable *memory_index;
157	GHashTable *memory_implementations;
158	} DesktopFileDir;
159
160	static GPtrArray *desktop_file_dirs = NULL;
161	static const gchar *desktop_file_dirs_config_dir = NULL;
162	static DesktopFileDir *desktop_file_dir_user_config = NULL; /* (owned) */
163	static DesktopFileDir *desktop_file_dir_user_data = NULL; /* (owned) */
164	static GMutex desktop_file_dir_lock;
165
166	/* Monitor 'changed' signal handler {{{2 */
167	static void desktop_file_dir_reset (DesktopFileDir *dir);
168
169	static DesktopFileDir *
170	desktop_file_dir_ref (DesktopFileDir *dir)
171	{
172	g_atomic_ref_count_inc (arc: &dir->ref_count);
173
174	return dir;
175	}
176
177	static void
178	desktop_file_dir_unref (DesktopFileDir *dir)
179	{
180	if (g_atomic_ref_count_dec (arc: &dir->ref_count))
181	{
182	desktop_file_dir_reset (dir);
183	g_free (mem: dir->path);
184	g_free (mem: dir);
185	}
186	}
187
188	/*< internal >
189	* desktop_file_dir_get_alternative_dir:
190	* @dir: a #DesktopFileDir
191	*
192	* Gets the "alternative" directory to monitor in case the path
193	* doesn't exist.
194	*
195	* If the path exists this will return NULL, otherwise it will return a
196	* parent directory of the path.
197	*
198	* This is used to avoid inotify on a non-existent directory (which
199	* results in polling).
200	*
201	* See https://bugzilla.gnome.org/show_bug.cgi?id=522314 for more info.
202	*/
203	static gchar *
204	desktop_file_dir_get_alternative_dir (DesktopFileDir *dir)
205	{
206	gchar *parent;
207
208	/* If the directory itself exists then we need no alternative. */
209	if (g_access (filename: dir->path, R_OK | X_OK) == 0)
210	return NULL;
211
212	/* Otherwise, try the parent directories until we find one. */
213	parent = g_path_get_dirname (file_name: dir->path);
214
215	while (g_access (filename: parent, R_OK | X_OK) != 0)
216	{
217	gchar *tmp = parent;
218
219	parent = g_path_get_dirname (file_name: tmp);
220
221	/* If somehow we get to '/' or '.' then just stop... */
222	if (g_str_equal (v1: parent, v2: tmp))
223	{
224	g_free (mem: tmp);
225	break;
226	}
227
228	g_free (mem: tmp);
229	}
230
231	return parent;
232	}
233
234	static void
235	desktop_file_dir_changed (GFileMonitor *monitor,
236	GFile *file,
237	GFile *other_file,
238	GFileMonitorEvent event_type,
239	gpointer user_data)
240	{
241	DesktopFileDir *dir = user_data;
242	gboolean do_nothing = FALSE;
243
244	/* We are not interested in receiving notifications forever just
245	* because someone asked about one desktop file once.
246	*
247	* After we receive the first notification, reset the dir, destroying
248	* the monitor. We will take this as a hint, next time that we are
249	* asked, that we need to check if everything is up to date.
250	*
251	* If this is a notification for a parent directory (because the
252	* desktop directory didn't exist) then we shouldn't fire the signal
253	* unless something actually changed.
254	*/
255	g_mutex_lock (mutex: &desktop_file_dir_lock);
256
257	if (dir->alternatively_watching)
258	{
259	gchar *alternative_dir;
260
261	alternative_dir = desktop_file_dir_get_alternative_dir (dir);
262	do_nothing = alternative_dir && g_str_equal (v1: dir->alternatively_watching, v2: alternative_dir);
263	g_free (mem: alternative_dir);
264	}
265
266	if (!do_nothing)
267	desktop_file_dir_reset (dir);
268
269	g_mutex_unlock (mutex: &desktop_file_dir_lock);
270
271	/* Notify anyone else who may be interested */
272	if (!do_nothing)
273	g_app_info_monitor_fire ();
274	}
275
276	/* Internal utility functions {{{2 */
277
278	/*< internal >
279	* desktop_file_dir_app_name_is_masked:
280	* @dir: a #DesktopFileDir
281	* @app_name: an application ID
282	*
283	* Checks if @app_name is masked for @dir.
284	*
285	* An application is masked if a similarly-named desktop file exists in
286	* a desktop file directory with higher precedence. Masked desktop
287	* files should be ignored.
288	*/
289	static gboolean
290	desktop_file_dir_app_name_is_masked (DesktopFileDir *dir,
291	const gchar *app_name)
292	{
293	guint i;
294
295	for (i = 0; i < desktop_file_dirs->len; i++)
296	{
297	DesktopFileDir *i_dir = g_ptr_array_index (desktop_file_dirs, i);
298
299	if (dir == i_dir)
300	return FALSE;
301	if (i_dir->app_names && g_hash_table_contains (hash_table: i_dir->app_names, key: app_name))
302	return TRUE;
303	}
304
305	return FALSE;
306	}
307
308	/* Not much to go on from https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html
309	* so validate it as a non-empty alphanumeric ASCII string with `-` and `_` allowed.
310	*
311	* Validation is important as the desktop IDs are used to construct filenames,
312	* and may be set by an unprivileged caller if running in a setuid program. */
313	static gboolean
314	validate_xdg_desktop (const gchar *desktop)
315	{
316	gsize i;
317
318	for (i = 0; desktop[i] != '\0'; i++)
319	if (desktop[i] != '-' && desktop[i] != '_' &&
320	!g_ascii_isalnum (desktop[i]))
321	return FALSE;
322
323	if (i == 0)
324	return FALSE;
325
326	return TRUE;
327	}
328
329	static char **
330	get_valid_current_desktops (const char *value)
331	{
332	char **tmp;
333	gsize i;
334	GPtrArray *valid_desktops;
335
336	if (value == NULL)
337	value = g_getenv (variable: "XDG_CURRENT_DESKTOP");
338	if (value == NULL)
339	value = "";
340
341	tmp = g_strsplit (string: value, G_SEARCHPATH_SEPARATOR_S, max_tokens: 0);
342	valid_desktops = g_ptr_array_new_full (reserved_size: g_strv_length (str_array: tmp) + 1, element_free_func: g_free);
343	for (i = 0; tmp[i]; i++)
344	{
345	if (validate_xdg_desktop (desktop: tmp[i]))
346	g_ptr_array_add (array: valid_desktops, data: tmp[i]);
347	else
348	g_free (mem: tmp[i]);
349	}
350	g_ptr_array_add (array: valid_desktops, NULL);
351	g_free (mem: tmp);
352	tmp = (char **) g_ptr_array_steal (array: valid_desktops, NULL);
353	g_ptr_array_unref (array: valid_desktops);
354	return tmp;
355	}
356
357	static const gchar * const *
358	get_lowercase_current_desktops (void)
359	{
360	static gchar **result;
361
362	if (g_once_init_enter (&result))
363	{
364	char **tmp = get_valid_current_desktops (NULL);
365	gsize i, j;
366
367	for (i = 0; tmp[i]; i++)
368	{
369	/* Convert to lowercase. */
370	for (j = 0; tmp[i][j]; j++)
371	tmp[i][j] = g_ascii_tolower (c: tmp[i][j]);
372	}
373
374	g_once_init_leave (&result, tmp);
375	}
376
377	return (const gchar **) result;
378	}
379
380	static const gchar * const *
381	get_current_desktops (const gchar *value)
382	{
383	static gchar **result;
384
385	if (g_once_init_enter (&result))
386	{
387	char **tmp = get_valid_current_desktops (value);
388
389	g_once_init_leave (&result, tmp);
390	}
391
392	return (const gchar **) result;
393	}
394
395	/*< internal >
396	* add_to_table_if_appropriate:
397	* @apps: a string to GDesktopAppInfo hash table
398	* @app_name: the name of the application
399	* @info: a #GDesktopAppInfo, or NULL
400	*
401	* If @info is non-%NULL and non-hidden, then add it to @apps, using
402	* @app_name as a key.
403	*
404	* If @info is non-%NULL then this function will consume the passed-in
405	* reference.
406	*/
407	static void
408	add_to_table_if_appropriate (GHashTable *apps,
409	const gchar *app_name,
410	GDesktopAppInfo *info)
411	{
412	if (!info)
413	return;
414
415	if (info->hidden)
416	{
417	g_object_unref (object: info);
418	return;
419	}
420
421	g_free (mem: info->desktop_id);
422	info->desktop_id = g_strdup (str: app_name);
423
424	g_hash_table_insert (hash_table: apps, key: g_strdup (str: info->desktop_id), value: info);
425	}
426
427	enum
428	{
429	DESKTOP_KEY_Comment,
430	DESKTOP_KEY_Exec,
431	DESKTOP_KEY_GenericName,
432	DESKTOP_KEY_Keywords,
433	DESKTOP_KEY_Name,
434	DESKTOP_KEY_X_GNOME_FullName,
435
436	N_DESKTOP_KEYS
437	};
438
439	const gchar desktop_key_match_category[N_DESKTOP_KEYS] = {
440	/* Note: lower numbers are a better match.
441	*
442	* In case we want two keys to match at the same level, we can just
443	* use the same number for the two different keys.
444	*/
445	[DESKTOP_KEY_Name] = 1,
446	[DESKTOP_KEY_Exec] = 2,
447	[DESKTOP_KEY_Keywords] = 3,
448	[DESKTOP_KEY_GenericName] = 4,
449	[DESKTOP_KEY_X_GNOME_FullName] = 5,
450	[DESKTOP_KEY_Comment] = 6
451	};
452
453	/* Common prefix commands to ignore from Exec= lines */
454	const char * const exec_key_match_blocklist[] = {
455	"bash",
456	"env",
457	"flatpak",
458	"gjs",
459	"pkexec",
460	"python",
461	"python2",
462	"python3",
463	"sh",
464	"wine",
465	"wine64",
466	NULL
467	};
468
469	static gchar *
470	desktop_key_get_name (guint key_id)
471	{
472	switch (key_id)
473	{
474	case DESKTOP_KEY_Comment:
475	return "Comment";
476	case DESKTOP_KEY_Exec:
477	return "Exec";
478	case DESKTOP_KEY_GenericName:
479	return GENERIC_NAME_KEY;
480	case DESKTOP_KEY_Keywords:
481	return KEYWORDS_KEY;
482	case DESKTOP_KEY_Name:
483	return "Name";
484	case DESKTOP_KEY_X_GNOME_FullName:
485	return FULL_NAME_KEY;
486	default:
487	g_assert_not_reached ();
488	}
489	}
490
491	/* Search global state {{{2
492	*
493	* We only ever search under a global lock, so we can use (and reuse)
494	* some global data to reduce allocations made while searching.
495	*
496	* In short, we keep around arrays of results that we expand as needed
497	* (and never shrink).
498	*
499	* static_token_results: this is where we append the results for each
500	* token within a given desktop directory, as we handle it (which is
501	* a union of all matches for this term)
502	*
503	* static_search_results: this is where we build the complete results
504	* for a single directory (which is an intersection of the matches
505	* found for each term)
506	*
507	* static_total_results: this is where we build the complete results
508	* across all directories (which is a union of the matches found in
509	* each directory)
510	*
511	* The app_names that enter these tables are always pointer-unique (in
512	* the sense that string equality is the same as pointer equality).
513	* This can be guaranteed for two reasons:
514	*
515	* - we mask appids so that a given appid will only ever appear within
516	* the highest-precedence directory that contains it. We never
517	* return search results from a lower-level directory if a desktop
518	* file exists in a higher-level one.
519	*
520	* - within a given directory, the string is unique because it's the
521	* key in the hashtable of all app_ids for that directory.
522	*
523	* We perform a merging of the results in merge_token_results(). This
524	* works by ordering the two lists and moving through each of them (at
525	* the same time) looking for common elements, rejecting uncommon ones.
526	* "Order" here need not mean any particular thing, as long as it is
527	* some order. Because of the uniqueness of our strings, we can use
528	* pointer order. That's what's going on in compare_results() below.
529	*/
530	struct search_result
531	{
532	const gchar *app_name;
533	gint category;
534	};
535
536	static struct search_result *static_token_results;
537	static gint static_token_results_size;
538	static gint static_token_results_allocated;
539	static struct search_result *static_search_results;
540	static gint static_search_results_size;
541	static gint static_search_results_allocated;
542	static struct search_result *static_total_results;
543	static gint static_total_results_size;
544	static gint static_total_results_allocated;
545
546	/* And some functions for performing nice operations against it */
547	static gint
548	compare_results (gconstpointer a,
549	gconstpointer b)
550	{
551	const struct search_result *ra = a;
552	const struct search_result *rb = b;
553
554	if (ra->app_name < rb->app_name)
555	return -1;
556
557	else if (ra->app_name > rb->app_name)
558	return 1;
559
560	else
561	return ra->category - rb->category;
562	}
563
564	static gint
565	compare_categories (gconstpointer a,
566	gconstpointer b)
567	{
568	const struct search_result *ra = a;
569	const struct search_result *rb = b;
570
571	return ra->category - rb->category;
572	}
573
574	static void
575	add_token_result (const gchar *app_name,
576	guint16 category)
577	{
578	if G_UNLIKELY (static_token_results_size == static_token_results_allocated)
579	{
580	static_token_results_allocated = MAX (16, static_token_results_allocated * 2);
581	static_token_results = g_renew (struct search_result, static_token_results, static_token_results_allocated);
582	}
583
584	static_token_results[static_token_results_size].app_name = app_name;
585	static_token_results[static_token_results_size].category = category;
586	static_token_results_size++;
587	}
588
589	static void
590	merge_token_results (gboolean first)
591	{
592	if (static_token_results_size != 0)
593	qsort (base: static_token_results, nmemb: static_token_results_size, size: sizeof (struct search_result), compar: compare_results);
594
595	/* If this is the first token then we are basically merging a list with
596	* itself -- we only perform de-duplication.
597	*
598	* If this is not the first token then we are doing a real merge.
599	*/
600	if (first)
601	{
602	const gchar *last_name = NULL;
603	gint i;
604
605	/* We must de-duplicate, but we do so by taking the best category
606	* in each case.
607	*
608	* The final list can be as large as the input here, so make sure
609	* we have enough room (even if it's too much room).
610	*/
611
612	if G_UNLIKELY (static_search_results_allocated < static_token_results_size)
613	{
614	static_search_results_allocated = static_token_results_allocated;
615	static_search_results = g_renew (struct search_result,
616	static_search_results,
617	static_search_results_allocated);
618	}
619
620	for (i = 0; i < static_token_results_size; i++)
621	{
622	/* The list is sorted so that the best match for a given id
623	* will be at the front, so once we have copied an id, skip
624	* the rest of the entries for the same id.
625	*/
626	if (static_token_results[i].app_name == last_name)
627	continue;
628
629	last_name = static_token_results[i].app_name;
630
631	static_search_results[static_search_results_size++] = static_token_results[i];
632	}
633	}
634	else
635	{
636	const gchar *last_name = NULL;
637	gint i, j = 0;
638	gint k = 0;
639
640	/* We only ever remove items from the results list, so no need to
641	* resize to ensure that we have enough room.
642	*/
643	for (i = 0; i < static_token_results_size; i++)
644	{
645	if (static_token_results[i].app_name == last_name)
646	continue;
647
648	last_name = static_token_results[i].app_name;
649
650	/* Now we only want to have a result in static_search_results
651	* if we already have it there *and* we have it in
652	* static_token_results as well. The category will be the
653	* lesser of the two.
654	*
655	* Skip past the results in static_search_results that are not
656	* going to be matches.
657	*/
658	while (k < static_search_results_size &&
659	static_search_results[k].app_name < static_token_results[i].app_name)
660	k++;
661
662	if (k < static_search_results_size &&
663	static_search_results[k].app_name == static_token_results[i].app_name)
664	{
665	/* We have a match.
666	*
667	* Category should be the worse of the two (ie:
668	* numerically larger).
669	*/
670	static_search_results[j].app_name = static_search_results[k].app_name;
671	static_search_results[j].category = MAX (static_search_results[k].category,
672	static_token_results[i].category);
673	j++;
674	}
675	}
676
677	static_search_results_size = j;
678	}
679
680	/* Clear it out for next time... */
681	static_token_results_size = 0;
682	}
683
684	static void
685	reset_total_search_results (void)
686	{
687	static_total_results_size = 0;
688	}
689
690	static void
691	sort_total_search_results (void)
692	{
693	if (static_total_results_size != 0)
694	qsort (base: static_total_results, nmemb: static_total_results_size, size: sizeof (struct search_result), compar: compare_categories);
695	}
696
697	static void
698	merge_directory_results (void)
699	{
700	if G_UNLIKELY (static_total_results_size + static_search_results_size > static_total_results_allocated)
701	{
702	static_total_results_allocated = MAX (16, static_total_results_allocated);
703	while (static_total_results_allocated < static_total_results_size + static_search_results_size)
704	static_total_results_allocated *= 2;
705	static_total_results = g_renew (struct search_result, static_total_results, static_total_results_allocated);
706	}
707
708	if (static_total_results + static_total_results_size != 0)
709	memcpy (dest: static_total_results + static_total_results_size,
710	src: static_search_results,
711	n: static_search_results_size * sizeof (struct search_result));
712
713	static_total_results_size += static_search_results_size;
714
715	/* Clear it out for next time... */
716	static_search_results_size = 0;
717	}
718
719	/* Support for unindexed DesktopFileDirs {{{2 */
720	static void
721	get_apps_from_dir (GHashTable **apps,
722	const char *dirname,
723	const char *prefix)
724	{
725	const char *basename;
726	GDir *dir;
727
728	dir = g_dir_open (path: dirname, flags: 0, NULL);
729
730	if (dir == NULL)
731	return;
732
733	while ((basename = g_dir_read_name (dir)) != NULL)
734	{
735	gchar *filename;
736
737	filename = g_build_filename (first_element: dirname, basename, NULL);
738
739	if (g_str_has_suffix (str: basename, suffix: ".desktop"))
740	{
741	gchar *app_name;
742
743	app_name = g_strconcat (string1: prefix, basename, NULL);
744
745	if (*apps == NULL)
746	*apps = g_hash_table_new_full (hash_func: g_str_hash, key_equal_func: g_str_equal, key_destroy_func: g_free, value_destroy_func: g_free);
747
748	g_hash_table_insert (hash_table: *apps, key: app_name, value: g_strdup (str: filename));
749	}
750	else if (g_file_test (filename, test: G_FILE_TEST_IS_DIR))
751	{
752	gchar *subprefix;
753
754	subprefix = g_strconcat (string1: prefix, basename, "-", NULL);
755	get_apps_from_dir (apps, dirname: filename, prefix: subprefix);
756	g_free (mem: subprefix);
757	}
758
759	g_free (mem: filename);
760	}
761
762	g_dir_close (dir);
763	}
764
765	typedef struct
766	{
767	gchar **additions;
768	gchar **removals;
769	gchar **defaults;
770	} UnindexedMimeTweaks;
771
772	static void
773	free_mime_tweaks (gpointer data)
774	{
775	UnindexedMimeTweaks *tweaks = data;
776
777	g_strfreev (str_array: tweaks->additions);
778	g_strfreev (str_array: tweaks->removals);
779	g_strfreev (str_array: tweaks->defaults);
780
781	g_slice_free (UnindexedMimeTweaks, tweaks);
782	}
783
784	static UnindexedMimeTweaks *
785	desktop_file_dir_unindexed_get_tweaks (DesktopFileDir *dir,
786	const gchar *mime_type)
787	{
788	UnindexedMimeTweaks *tweaks;
789	gchar *unaliased_type;
790
791	unaliased_type = _g_unix_content_type_unalias (type: mime_type);
792	tweaks = g_hash_table_lookup (hash_table: dir->mime_tweaks, key: unaliased_type);
793
794	if (tweaks == NULL)
795	{
796	tweaks = g_slice_new0 (UnindexedMimeTweaks);
797	g_hash_table_insert (hash_table: dir->mime_tweaks, key: unaliased_type, value: tweaks);
798	}
799	else
800	g_free (mem: unaliased_type);
801
802	return tweaks;
803	}
804
805	/* consumes 'to_add' */
806	static void
807	expand_strv (gchar ***strv_ptr,
808	gchar **to_add,
809	gchar * const *blocklist)
810	{
811	guint strv_len, add_len;
812	gchar **strv;
813	guint i, j;
814
815	if (!*strv_ptr)
816	{
817	*strv_ptr = to_add;
818	return;
819	}
820
821	strv = *strv_ptr;
822	strv_len = g_strv_length (str_array: strv);
823	add_len = g_strv_length (str_array: to_add);
824	strv = g_renew (gchar *, strv, strv_len + add_len + 1);
825
826	for (i = 0; to_add[i]; i++)
827	{
828	/* Don't add blocklisted strings */
829	if (blocklist)
830	for (j = 0; blocklist[j]; j++)
831	if (g_str_equal (v1: to_add[i], v2: blocklist[j]))
832	goto no_add;
833
834	/* Don't add duplicates already in the list */
835	for (j = 0; j < strv_len; j++)
836	if (g_str_equal (v1: to_add[i], v2: strv[j]))
837	goto no_add;
838
839	strv[strv_len++] = to_add[i];
840	continue;
841
842	no_add:
843	g_free (mem: to_add[i]);
844	}
845
846	strv[strv_len] = NULL;
847	*strv_ptr = strv;
848
849	g_free (mem: to_add);
850	}
851
852	static void
853	desktop_file_dir_unindexed_read_mimeapps_list (DesktopFileDir *dir,
854	const gchar *filename,
855	const gchar *added_group,
856	gboolean tweaks_permitted)
857	{
858	UnindexedMimeTweaks *tweaks;
859	char **desktop_file_ids;
860	GKeyFile *key_file;
861	gchar **mime_types;
862	int i;
863
864	key_file = g_key_file_new ();
865	if (!g_key_file_load_from_file (key_file, file: filename, flags: G_KEY_FILE_NONE, NULL))
866	{
867	g_key_file_free (key_file);
868	return;
869	}
870
871	mime_types = g_key_file_get_keys (key_file, group_name: added_group, NULL, NULL);
872
873	if G_UNLIKELY (mime_types != NULL && !tweaks_permitted)
874	{
875	g_warning ("%s contains a [%s] group, but it is not permitted here. Only the non-desktop-specific "
876	"mimeapps.list file may add or remove associations.", filename, added_group);
877	g_strfreev (str_array: mime_types);
878	mime_types = NULL;
879	}
880
881	if (mime_types != NULL)
882	{
883	for (i = 0; mime_types[i] != NULL; i++)
884	{
885	desktop_file_ids = g_key_file_get_string_list (key_file, group_name: added_group, key: mime_types[i], NULL, NULL);
886
887	if (desktop_file_ids)
888	{
889	tweaks = desktop_file_dir_unindexed_get_tweaks (dir, mime_type: mime_types[i]);
890	expand_strv (strv_ptr: &tweaks->additions, to_add: desktop_file_ids, blocklist: tweaks->removals);
891	}
892	}
893
894	g_strfreev (str_array: mime_types);
895	}
896
897	mime_types = g_key_file_get_keys (key_file, REMOVED_ASSOCIATIONS_GROUP, NULL, NULL);
898
899	if G_UNLIKELY (mime_types != NULL && !tweaks_permitted)
900	{
901	g_warning ("%s contains a [%s] group, but it is not permitted here. Only the non-desktop-specific "
902	"mimeapps.list file may add or remove associations.", filename, REMOVED_ASSOCIATIONS_GROUP);
903	g_strfreev (str_array: mime_types);
904	mime_types = NULL;
905	}
906
907	if (mime_types != NULL)
908	{
909	for (i = 0; mime_types[i] != NULL; i++)
910	{
911	desktop_file_ids = g_key_file_get_string_list (key_file, REMOVED_ASSOCIATIONS_GROUP, key: mime_types[i], NULL, NULL);
912
913	if (desktop_file_ids)
914	{
915	tweaks = desktop_file_dir_unindexed_get_tweaks (dir, mime_type: mime_types[i]);
916	expand_strv (strv_ptr: &tweaks->removals, to_add: desktop_file_ids, blocklist: tweaks->additions);
917	}
918	}
919
920	g_strfreev (str_array: mime_types);
921	}
922
923	mime_types = g_key_file_get_keys (key_file, DEFAULT_APPLICATIONS_GROUP, NULL, NULL);
924
925	if (mime_types != NULL)
926	{
927	for (i = 0; mime_types[i] != NULL; i++)
928	{
929	desktop_file_ids = g_key_file_get_string_list (key_file, DEFAULT_APPLICATIONS_GROUP, key: mime_types[i], NULL, NULL);
930
931	if (desktop_file_ids)
932	{
933	tweaks = desktop_file_dir_unindexed_get_tweaks (dir, mime_type: mime_types[i]);
934	expand_strv (strv_ptr: &tweaks->defaults, to_add: desktop_file_ids, NULL);
935	}
936	}
937
938	g_strfreev (str_array: mime_types);
939	}
940
941	g_key_file_free (key_file);
942	}
943
944	static void
945	desktop_file_dir_unindexed_read_mimeapps_lists (DesktopFileDir *dir)
946	{
947	const gchar * const *desktops;
948	gchar *filename;
949	gint i;
950
951	dir->mime_tweaks = g_hash_table_new_full (hash_func: g_str_hash, key_equal_func: g_str_equal, key_destroy_func: g_free, value_destroy_func: free_mime_tweaks);
952
953	/* We process in order of precedence, using a blocklisting approach to
954	* avoid recording later instructions that conflict with ones we found
955	* earlier.
956	*
957	* We first start with the XDG_CURRENT_DESKTOP files, in precedence
958	* order.
959	*/
960	desktops = get_lowercase_current_desktops ();
961	for (i = 0; desktops[i]; i++)
962	{
963	filename = g_strdup_printf (format: "%s/%s-mimeapps.list", dir->path, desktops[i]);
964	desktop_file_dir_unindexed_read_mimeapps_list (dir, filename, ADDED_ASSOCIATIONS_GROUP, FALSE);
965	g_free (mem: filename);
966	}
967
968	/* Next, the non-desktop-specific mimeapps.list */
969	filename = g_strdup_printf (format: "%s/mimeapps.list", dir->path);
970	desktop_file_dir_unindexed_read_mimeapps_list (dir, filename, ADDED_ASSOCIATIONS_GROUP, TRUE);
971	g_free (mem: filename);
972
973	/* The remaining files are only checked for in directories that might
974	* contain desktop files (ie: not the config dirs).
975	*/
976	if (dir->is_config)
977	return;
978
979	/* We have 'defaults.list' which was only ever understood by GLib. It
980	* exists widely, but it has never been part of any spec and it should
981	* be treated as deprecated. This will be removed in a future
982	* version.
983	*/
984	filename = g_strdup_printf (format: "%s/defaults.list", dir->path);
985	desktop_file_dir_unindexed_read_mimeapps_list (dir, filename, ADDED_ASSOCIATIONS_GROUP, FALSE);
986	g_free (mem: filename);
987
988	/* Finally, the mimeinfo.cache, which is just a cached copy of what we
989	* would find in the MimeTypes= lines of all of the desktop files.
990	*/
991	filename = g_strdup_printf (format: "%s/mimeinfo.cache", dir->path);
992	desktop_file_dir_unindexed_read_mimeapps_list (dir, filename, MIME_CACHE_GROUP, TRUE);
993	g_free (mem: filename);
994	}
995
996	static void
997	desktop_file_dir_unindexed_init (DesktopFileDir *dir)
998	{
999	if (!dir->is_config)
1000	get_apps_from_dir (apps: &dir->app_names, dirname: dir->path, prefix: "");
1001
1002	desktop_file_dir_unindexed_read_mimeapps_lists (dir);
1003	}
1004
1005	static GDesktopAppInfo *
1006	desktop_file_dir_unindexed_get_app (DesktopFileDir *dir,
1007	const gchar *desktop_id)
1008	{
1009	const gchar *filename;
1010
1011	filename = g_hash_table_lookup (hash_table: dir->app_names, key: desktop_id);
1012
1013	if (!filename)
1014	return NULL;
1015
1016	return g_desktop_app_info_new_from_filename (filename);
1017	}
1018
1019	static void
1020	desktop_file_dir_unindexed_get_all (DesktopFileDir *dir,
1021	GHashTable *apps)
1022	{
1023	GHashTableIter iter;
1024	gpointer app_name;
1025	gpointer filename;
1026
1027	if (dir->app_names == NULL)
1028	return;
1029
1030	g_hash_table_iter_init (iter: &iter, hash_table: dir->app_names);
1031	while (g_hash_table_iter_next (iter: &iter, key: &app_name, value: &filename))
1032	{
1033	if (desktop_file_dir_app_name_is_masked (dir, app_name))
1034	continue;
1035
1036	add_to_table_if_appropriate (apps, app_name, info: g_desktop_app_info_new_from_filename (filename));
1037	}
1038	}
1039
1040	typedef struct _MemoryIndexEntry MemoryIndexEntry;
1041	typedef GHashTable MemoryIndex;
1042
1043	struct _MemoryIndexEntry
1044	{
1045	const gchar *app_name; /* pointer to the hashtable key */
1046	gint match_category;
1047	MemoryIndexEntry *next;
1048	};
1049
1050	static void
1051	memory_index_entry_free (gpointer data)
1052	{
1053	MemoryIndexEntry *mie = data;
1054
1055	while (mie)
1056	{
1057	MemoryIndexEntry *next = mie->next;
1058
1059	g_slice_free (MemoryIndexEntry, mie);
1060	mie = next;
1061	}
1062	}
1063
1064	static void
1065	memory_index_add_token (MemoryIndex *mi,
1066	const gchar *token,
1067	gint match_category,
1068	const gchar *app_name)
1069	{
1070	MemoryIndexEntry *mie, *first;
1071
1072	mie = g_slice_new (MemoryIndexEntry);
1073	mie->app_name = app_name;
1074	mie->match_category = match_category;
1075
1076	first = g_hash_table_lookup (hash_table: mi, key: token);
1077
1078	if (first)
1079	{
1080	mie->next = first->next;
1081	first->next = mie;
1082	}
1083	else
1084	{
1085	mie->next = NULL;
1086	g_hash_table_insert (hash_table: mi, key: g_strdup (str: token), value: mie);
1087	}
1088	}
1089
1090	static void
1091	memory_index_add_string (MemoryIndex *mi,
1092	const gchar *string,
1093	gint match_category,
1094	const gchar *app_name)
1095	{
1096	gchar **tokens, **alternates;
1097	gint i;
1098
1099	tokens = g_str_tokenize_and_fold (string, NULL, ascii_alternates: &alternates);
1100
1101	for (i = 0; tokens[i]; i++)
1102	memory_index_add_token (mi, token: tokens[i], match_category, app_name);
1103
1104	for (i = 0; alternates[i]; i++)
1105	memory_index_add_token (mi, token: alternates[i], match_category, app_name);
1106
1107	g_strfreev (str_array: alternates);
1108	g_strfreev (str_array: tokens);
1109	}
1110
1111	static MemoryIndex *
1112	memory_index_new (void)
1113	{
1114	return g_hash_table_new_full (hash_func: g_str_hash, key_equal_func: g_str_equal, key_destroy_func: g_free, value_destroy_func: memory_index_entry_free);
1115	}
1116
1117	static void
1118	desktop_file_dir_unindexed_setup_search (DesktopFileDir *dir)
1119	{
1120	GHashTableIter iter;
1121	gpointer app, path;
1122
1123	dir->memory_index = memory_index_new ();
1124	dir->memory_implementations = memory_index_new ();
1125
1126	/* Nothing to search? */
1127	if (dir->app_names == NULL)
1128	return;
1129
1130	g_hash_table_iter_init (iter: &iter, hash_table: dir->app_names);
1131	while (g_hash_table_iter_next (iter: &iter, key: &app, value: &path))
1132	{
1133	GKeyFile *key_file;
1134
1135	if (desktop_file_dir_app_name_is_masked (dir, app_name: app))
1136	continue;
1137
1138	key_file = g_key_file_new ();
1139
1140	if (g_key_file_load_from_file (key_file, file: path, flags: G_KEY_FILE_NONE, NULL) &&
1141	!g_key_file_get_boolean (key_file, group_name: "Desktop Entry", key: "Hidden", NULL))
1142	{
1143	/* Index the interesting keys... */
1144	gchar **implements;
1145	gsize i;
1146
1147	for (i = 0; i < G_N_ELEMENTS (desktop_key_match_category); i++)
1148	{
1149	const gchar *value;
1150	gchar *raw;
1151
1152	if (!desktop_key_match_category[i])
1153	continue;
1154
1155	raw = g_key_file_get_locale_string (key_file, group_name: "Desktop Entry", key: desktop_key_get_name (key_id: i), NULL, NULL);
1156	value = raw;
1157
1158	if (i == DESKTOP_KEY_Exec && raw != NULL)
1159	{
1160	/* Special handling: only match basename of first field */
1161	gchar *space;
1162	gchar *slash;
1163
1164	/* Remove extra arguments, if any */
1165	space = raw + strcspn (s: raw, reject: " \t\n"); /* IFS */
1166	*space = '\0';
1167
1168	/* Skip the pathname, if any */
1169	if ((slash = strrchr (s: raw, c: '/')))
1170	value = slash + 1;
1171
1172	/* Don't match on blocklisted binaries like interpreters */
1173	if (g_strv_contains (strv: exec_key_match_blocklist, str: value))
1174	value = NULL;
1175	}
1176
1177	if (value)
1178	memory_index_add_string (mi: dir->memory_index, string: value, match_category: desktop_key_match_category[i], app_name: app);
1179
1180	g_free (mem: raw);
1181	}
1182
1183	/* Make note of the Implements= line */
1184	implements = g_key_file_get_string_list (key_file, group_name: "Desktop Entry", key: "Implements", NULL, NULL);
1185	for (i = 0; implements && implements[i]; i++)
1186	memory_index_add_token (mi: dir->memory_implementations, token: implements[i], match_category: 0, app_name: app);
1187	g_strfreev (str_array: implements);
1188	}
1189
1190	g_key_file_free (key_file);
1191	}
1192	}
1193
1194	static void
1195	desktop_file_dir_unindexed_search (DesktopFileDir *dir,
1196	const gchar *search_token)
1197	{
1198	GHashTableIter iter;
1199	gpointer key, value;
1200
1201	if (!dir->memory_index)
1202	desktop_file_dir_unindexed_setup_search (dir);
1203
1204	g_hash_table_iter_init (iter: &iter, hash_table: dir->memory_index);
1205	while (g_hash_table_iter_next (iter: &iter, key: &key, value: &value))
1206	{
1207	MemoryIndexEntry *mie = value;
1208
1209	if (!g_str_has_prefix (str: key, prefix: search_token))
1210	continue;
1211
1212	while (mie)
1213	{
1214	add_token_result (app_name: mie->app_name, category: mie->match_category);
1215	mie = mie->next;
1216	}
1217	}
1218	}
1219
1220	static gboolean
1221	array_contains (GPtrArray *array,
1222	const gchar *str)
1223	{
1224	guint i;
1225
1226	for (i = 0; i < array->len; i++)
1227	if (g_str_equal (v1: array->pdata[i], v2: str))
1228	return TRUE;
1229
1230	return FALSE;
1231	}
1232
1233	static void
1234	desktop_file_dir_unindexed_mime_lookup (DesktopFileDir *dir,
1235	const gchar *mime_type,
1236	GPtrArray *hits,
1237	GPtrArray *blocklist)
1238	{
1239	UnindexedMimeTweaks *tweaks;
1240	gint i;
1241
1242	tweaks = g_hash_table_lookup (hash_table: dir->mime_tweaks, key: mime_type);
1243
1244	if (!tweaks)
1245	return;
1246
1247	if (tweaks->additions)
1248	{
1249	for (i = 0; tweaks->additions[i]; i++)
1250	{
1251	gchar *app_name = tweaks->additions[i];
1252
1253	if (!desktop_file_dir_app_name_is_masked (dir, app_name) &&
1254	!array_contains (array: blocklist, str: app_name) && !array_contains (array: hits, str: app_name))
1255	g_ptr_array_add (array: hits, data: app_name);
1256	}
1257	}
1258
1259	if (tweaks->removals)
1260	{
1261	for (i = 0; tweaks->removals[i]; i++)
1262	{
1263	gchar *app_name = tweaks->removals[i];
1264
1265	if (!desktop_file_dir_app_name_is_masked (dir, app_name) &&
1266	!array_contains (array: blocklist, str: app_name) && !array_contains (array: hits, str: app_name))
1267	g_ptr_array_add (array: blocklist, data: app_name);
1268	}
1269	}
1270	}
1271
1272	static void
1273	desktop_file_dir_unindexed_default_lookup (DesktopFileDir *dir,
1274	const gchar *mime_type,
1275	GPtrArray *results)
1276	{
1277	UnindexedMimeTweaks *tweaks;
1278	gint i;
1279
1280	tweaks = g_hash_table_lookup (hash_table: dir->mime_tweaks, key: mime_type);
1281
1282	if (!tweaks || !tweaks->defaults)
1283	return;
1284
1285	for (i = 0; tweaks->defaults[i]; i++)
1286	{
1287	gchar *app_name = tweaks->defaults[i];
1288
1289	if (!array_contains (array: results, str: app_name))
1290	g_ptr_array_add (array: results, data: app_name);
1291	}
1292	}
1293
1294	static void
1295	desktop_file_dir_unindexed_get_implementations (DesktopFileDir *dir,
1296	GList **results,
1297	const gchar *interface)
1298	{
1299	MemoryIndexEntry *mie;
1300
1301	if (!dir->memory_index)
1302	desktop_file_dir_unindexed_setup_search (dir);
1303
1304	for (mie = g_hash_table_lookup (hash_table: dir->memory_implementations, key: interface); mie; mie = mie->next)
1305	*results = g_list_prepend (list: *results, data: g_strdup (str: mie->app_name));
1306	}
1307
1308	/* DesktopFileDir "API" {{{2 */
1309
1310	/*< internal >
1311	* desktop_file_dir_new:
1312	* @data_dir: an XDG_DATA_DIR
1313	*
1314	* Creates a #DesktopFileDir for the corresponding @data_dir.
1315	*/
1316	static DesktopFileDir *
1317	desktop_file_dir_new (const gchar *data_dir)
1318	{
1319	DesktopFileDir *dir = g_new0 (DesktopFileDir, 1);
1320
1321	g_atomic_ref_count_init (arc: &dir->ref_count);
1322	dir->path = g_build_filename (first_element: data_dir, "applications", NULL);
1323
1324	return g_steal_pointer (&dir);
1325	}
1326
1327	/*< internal >
1328	* desktop_file_dir_new_for_config:
1329	* @config_dir: an XDG_CONFIG_DIR
1330	*
1331	* Just the same as desktop_file_dir_new() except that it does not
1332	* add the "applications" directory. It also marks the directory as
1333	* config-only, which prevents us from attempting to find desktop files
1334	* here.
1335	*/
1336	static DesktopFileDir *
1337	desktop_file_dir_new_for_config (const gchar *config_dir)
1338	{
1339	DesktopFileDir *dir = g_new0 (DesktopFileDir, 1);
1340
1341	g_atomic_ref_count_init (arc: &dir->ref_count);
1342	dir->path = g_strdup (str: config_dir);
1343	dir->is_config = TRUE;
1344
1345	return g_steal_pointer (&dir);
1346	}
1347
1348	/*< internal >
1349	* desktop_file_dir_reset:
1350	* @dir: a #DesktopFileDir
1351	*
1352	* Cleans up @dir, releasing most resources that it was using.
1353	*/
1354	static void
1355	desktop_file_dir_reset (DesktopFileDir *dir)
1356	{
1357	if (dir->alternatively_watching)
1358	{
1359	g_free (mem: dir->alternatively_watching);
1360	dir->alternatively_watching = NULL;
1361	}
1362
1363	if (dir->monitor)
1364	{
1365	g_signal_handlers_disconnect_by_func (dir->monitor, desktop_file_dir_changed, dir);
1366	g_file_monitor_cancel (monitor: dir->monitor);
1367	g_object_unref (object: dir->monitor);
1368	dir->monitor = NULL;
1369	}
1370
1371	if (dir->app_names)
1372	{
1373	g_hash_table_unref (hash_table: dir->app_names);
1374	dir->app_names = NULL;
1375	}
1376
1377	if (dir->memory_index)
1378	{
1379	g_hash_table_unref (hash_table: dir->memory_index);
1380	dir->memory_index = NULL;
1381	}
1382
1383	if (dir->mime_tweaks)
1384	{
1385	g_hash_table_unref (hash_table: dir->mime_tweaks);
1386	dir->mime_tweaks = NULL;
1387	}
1388
1389	if (dir->memory_implementations)
1390	{
1391	g_hash_table_unref (hash_table: dir->memory_implementations);
1392	dir->memory_implementations = NULL;
1393	}
1394
1395	dir->is_setup = FALSE;
1396	}
1397
1398	static void
1399	closure_notify_cb (gpointer data,
1400	GClosure *closure)
1401	{
1402	DesktopFileDir *dir = data;
1403	desktop_file_dir_unref (dir);
1404	}
1405
1406	/*< internal >
1407	* desktop_file_dir_init:
1408	* @dir: a #DesktopFileDir
1409	*
1410	* Does initial setup for @dir
1411	*
1412	* You should only call this if @dir is not already setup.
1413	*/
1414	static void
1415	desktop_file_dir_init (DesktopFileDir *dir)
1416	{
1417	const gchar *watch_dir;
1418
1419	g_assert (!dir->is_setup);
1420
1421	g_assert (!dir->alternatively_watching);
1422	g_assert (!dir->monitor);
1423
1424	dir->alternatively_watching = desktop_file_dir_get_alternative_dir (dir);
1425	watch_dir = dir->alternatively_watching ? dir->alternatively_watching : dir->path;
1426
1427	/* There is a very thin race here if the watch_dir has been _removed_
1428	* between when we checked for it and when we establish the watch.
1429	* Removes probably don't happen in usual operation, and even if it
1430	* does (and we catch the unlikely race), the only degradation is that
1431	* we will fall back to polling.
1432	*/
1433	dir->monitor = g_local_file_monitor_new_in_worker (pathname: watch_dir, TRUE, flags: G_FILE_MONITOR_NONE,
1434	callback: desktop_file_dir_changed,
1435	user_data: desktop_file_dir_ref (dir),
1436	destroy_user_data: closure_notify_cb, NULL);
1437
1438	desktop_file_dir_unindexed_init (dir);
1439
1440	dir->is_setup = TRUE;
1441	}
1442
1443	/*< internal >
1444	* desktop_file_dir_get_app:
1445	* @dir: a DesktopFileDir
1446	* @desktop_id: the desktop ID to load
1447	*
1448	* Creates the #GDesktopAppInfo for the given @desktop_id if it exists
1449	* within @dir, even if it is hidden.
1450	*
1451	* This function does not check if @desktop_id would be masked by a
1452	* directory with higher precedence. The caller must do so.
1453	*/
1454	static GDesktopAppInfo *
1455	desktop_file_dir_get_app (DesktopFileDir *dir,
1456	const gchar *desktop_id)
1457	{
1458	if (!dir->app_names)
1459	return NULL;
1460
1461	return desktop_file_dir_unindexed_get_app (dir, desktop_id);
1462	}
1463
1464	/*< internal >
1465	* desktop_file_dir_get_all:
1466	* @dir: a DesktopFileDir
1467	* @apps: a #GHashTable<string, GDesktopAppInfo>
1468	*
1469	* Loads all desktop files in @dir and adds them to @apps, careful to
1470	* ensure we don't add any files masked by a similarly-named file in a
1471	* higher-precedence directory.
1472	*/
1473	static void
1474	desktop_file_dir_get_all (DesktopFileDir *dir,
1475	GHashTable *apps)
1476	{
1477	desktop_file_dir_unindexed_get_all (dir, apps);
1478	}
1479
1480	/*< internal >
1481	* desktop_file_dir_mime_lookup:
1482	* @dir: a #DesktopFileDir
1483	* @mime_type: the mime type to look up
1484	* @hits: the array to store the hits
1485	* @blocklist: the array to store the blocklist
1486	*
1487	* Does a lookup of a mimetype against one desktop file directory,
1488	* recording any hits and blocklisting and "Removed" associations (so
1489	* later directories don't record them as hits).
1490	*
1491	* The items added to @hits are duplicated, but the ones in @blocklist
1492	* are weak pointers. This facilitates simply freeing the blocklist
1493	* (which is only used for internal bookkeeping) but using the pdata of
1494	* @hits as the result of the operation.
1495	*/
1496	static void
1497	desktop_file_dir_mime_lookup (DesktopFileDir *dir,
1498	const gchar *mime_type,
1499	GPtrArray *hits,
1500	GPtrArray *blocklist)
1501	{
1502	desktop_file_dir_unindexed_mime_lookup (dir, mime_type, hits, blocklist);
1503	}
1504
1505	/*< internal >
1506	* desktop_file_dir_default_lookup:
1507	* @dir: a #DesktopFileDir
1508	* @mime_type: the mime type to look up
1509	* @results: an array to store the results in
1510	*
1511	* Collects the "default" applications for a given mime type from @dir.
1512	*/
1513	static void
1514	desktop_file_dir_default_lookup (DesktopFileDir *dir,
1515	const gchar *mime_type,
1516	GPtrArray *results)
1517	{
1518	desktop_file_dir_unindexed_default_lookup (dir, mime_type, results);
1519	}
1520
1521	/*< internal >
1522	* desktop_file_dir_search:
1523	* @dir: a #DesktopFileDir
1524	* @term: a normalised and casefolded search term
1525	*
1526	* Finds the names of applications in @dir that match @term.
1527	*/
1528	static void
1529	desktop_file_dir_search (DesktopFileDir *dir,
1530	const gchar *search_token)
1531	{
1532	desktop_file_dir_unindexed_search (dir, search_token);
1533	}
1534
1535	static void
1536	desktop_file_dir_get_implementations (DesktopFileDir *dir,
1537	GList **results,
1538	const gchar *interface)
1539	{
1540	desktop_file_dir_unindexed_get_implementations (dir, results, interface);
1541	}
1542
1543	/* Lock/unlock and global setup API {{{2 */
1544
1545	static void
1546	desktop_file_dirs_lock (void)
1547	{
1548	guint i;
1549	const gchar *user_config_dir = g_get_user_config_dir ();
1550
1551	g_mutex_lock (mutex: &desktop_file_dir_lock);
1552
1553	/* If the XDG dirs configuration has changed (expected only during tests),
1554	* clear and reload the state. */
1555	if (desktop_file_dirs_config_dir != NULL &&
1556	g_strcmp0 (str1: desktop_file_dirs_config_dir, str2: user_config_dir) != 0)
1557	{
1558	g_debug ("%s: Resetting desktop app info dirs from %s to %s",
1559	G_STRFUNC, desktop_file_dirs_config_dir, user_config_dir);
1560
1561	g_ptr_array_set_size (array: desktop_file_dirs, length: 0);
1562	g_clear_pointer (&desktop_file_dir_user_config, desktop_file_dir_unref);
1563	g_clear_pointer (&desktop_file_dir_user_data, desktop_file_dir_unref);
1564	}
1565
1566	if (desktop_file_dirs == NULL || desktop_file_dirs->len == 0)
1567	{
1568	const char * const *dirs;
1569	gint i;
1570
1571	if (desktop_file_dirs == NULL)
1572	desktop_file_dirs = g_ptr_array_new_with_free_func (element_free_func: (GDestroyNotify) desktop_file_dir_unref);
1573
1574	/* First, the configs. Highest priority: the user's ~/.config */
1575	desktop_file_dir_user_config = desktop_file_dir_new_for_config (config_dir: user_config_dir);
1576	g_ptr_array_add (array: desktop_file_dirs, data: desktop_file_dir_ref (dir: desktop_file_dir_user_config));
1577
1578	/* Next, the system configs (/etc/xdg, and so on). */
1579	dirs = g_get_system_config_dirs ();
1580	for (i = 0; dirs[i]; i++)
1581	g_ptr_array_add (array: desktop_file_dirs, data: desktop_file_dir_new_for_config (config_dir: dirs[i]));
1582
1583	/* Now the data. Highest priority: the user's ~/.local/share/applications */
1584	desktop_file_dir_user_data = desktop_file_dir_new (data_dir: g_get_user_data_dir ());
1585	g_ptr_array_add (array: desktop_file_dirs, data: desktop_file_dir_ref (dir: desktop_file_dir_user_data));
1586
1587	/* Following that, XDG_DATA_DIRS/applications, in order */
1588	dirs = g_get_system_data_dirs ();
1589	for (i = 0; dirs[i]; i++)
1590	g_ptr_array_add (array: desktop_file_dirs, data: desktop_file_dir_new (data_dir: dirs[i]));
1591
1592	/* The list of directories will never change after this, unless
1593	* g_get_user_config_dir() changes due to %G_TEST_OPTION_ISOLATE_DIRS. */
1594	desktop_file_dirs_config_dir = user_config_dir;
1595	}
1596
1597	for (i = 0; i < desktop_file_dirs->len; i++)
1598	if (!((DesktopFileDir *) g_ptr_array_index (desktop_file_dirs, i))->is_setup)
1599	desktop_file_dir_init (g_ptr_array_index (desktop_file_dirs, i));
1600	}
1601
1602	static void
1603	desktop_file_dirs_unlock (void)
1604	{
1605	g_mutex_unlock (mutex: &desktop_file_dir_lock);
1606	}
1607
1608	static void
1609	desktop_file_dirs_invalidate_user_config (void)
1610	{
1611	g_mutex_lock (mutex: &desktop_file_dir_lock);
1612
1613	if (desktop_file_dir_user_config != NULL)
1614	desktop_file_dir_reset (dir: desktop_file_dir_user_config);
1615
1616	g_mutex_unlock (mutex: &desktop_file_dir_lock);
1617	}
1618
1619	static void
1620	desktop_file_dirs_invalidate_user_data (void)
1621	{
1622	g_mutex_lock (mutex: &desktop_file_dir_lock);
1623
1624	if (desktop_file_dir_user_data != NULL)
1625	desktop_file_dir_reset (dir: desktop_file_dir_user_data);
1626
1627	g_mutex_unlock (mutex: &desktop_file_dir_lock);
1628	}
1629
1630	/* GDesktopAppInfo implementation {{{1 */
1631	/* GObject implementation {{{2 */
1632	static void
1633	g_desktop_app_info_finalize (GObject *object)
1634	{
1635	GDesktopAppInfo *info;
1636
1637	info = G_DESKTOP_APP_INFO (object);
1638
1639	g_free (mem: info->desktop_id);
1640	g_free (mem: info->filename);
1641
1642	if (info->keyfile)
1643	g_key_file_unref (key_file: info->keyfile);
1644
1645	g_free (mem: info->name);
1646	g_free (mem: info->generic_name);
1647	g_free (mem: info->fullname);
1648	g_free (mem: info->comment);
1649	g_free (mem: info->icon_name);
1650	if (info->icon)
1651	g_object_unref (object: info->icon);
1652	g_strfreev (str_array: info->keywords);
1653	g_strfreev (str_array: info->only_show_in);
1654	g_strfreev (str_array: info->not_show_in);
1655	g_free (mem: info->try_exec);
1656	g_free (mem: info->exec);
1657	g_free (mem: info->binary);
1658	g_free (mem: info->path);
1659	g_free (mem: info->categories);
1660	g_free (mem: info->startup_wm_class);
1661	g_strfreev (str_array: info->mime_types);
1662	g_free (mem: info->app_id);
1663	g_strfreev (str_array: info->actions);
1664
1665	G_OBJECT_CLASS (g_desktop_app_info_parent_class)->finalize (object);
1666	}
1667
1668	static void
1669	g_desktop_app_info_set_property (GObject *object,
1670	guint prop_id,
1671	const GValue *value,
1672	GParamSpec *pspec)
1673	{
1674	GDesktopAppInfo *self = G_DESKTOP_APP_INFO (object);
1675
1676	switch (prop_id)
1677	{
1678	case PROP_FILENAME:
1679	self->filename = g_value_dup_string (value);
1680	break;
1681
1682	default:
1683	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1684	break;
1685	}
1686	}
1687
1688	static void
1689	g_desktop_app_info_get_property (GObject *object,
1690	guint prop_id,
1691	GValue *value,
1692	GParamSpec *pspec)
1693	{
1694	GDesktopAppInfo *self = G_DESKTOP_APP_INFO (object);
1695
1696	switch (prop_id)
1697	{
1698	case PROP_FILENAME:
1699	g_value_set_string (value, v_string: self->filename);
1700	break;
1701	default:
1702	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1703	break;
1704	}
1705	}
1706
1707	static void
1708	g_desktop_app_info_class_init (GDesktopAppInfoClass *klass)
1709	{
1710	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
1711
1712	gobject_class->get_property = g_desktop_app_info_get_property;
1713	gobject_class->set_property = g_desktop_app_info_set_property;
1714	gobject_class->finalize = g_desktop_app_info_finalize;
1715
1716	/**
1717	* GDesktopAppInfo:filename:
1718	*
1719	* The origin filename of this #GDesktopAppInfo
1720	*/
1721	g_object_class_install_property (oclass: gobject_class,
1722	property_id: PROP_FILENAME,
1723	pspec: g_param_spec_string (name: "filename", nick: "Filename", blurb: "", NULL,
1724	flags: G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1725	}
1726
1727	static void
1728	g_desktop_app_info_init (GDesktopAppInfo *local)
1729	{
1730	}
1731
1732	/* Construction... {{{2 */
1733
1734	/*< internal >
1735	* binary_from_exec:
1736	* @exec: an exec line
1737	*
1738	* Returns the first word in an exec line (ie: the binary name).
1739	*
1740	* If @exec is " progname --foo %F" then returns "progname".
1741	*/
1742	static char *
1743	binary_from_exec (const char *exec)
1744	{
1745	const char *p, *start;
1746
1747	p = exec;
1748	while (*p == ' ')
1749	p++;
1750	start = p;
1751	while (*p != ' ' && *p != 0)
1752	p++;
1753
1754	return g_strndup (str: start, n: p - start);
1755	}
1756
1757	static gboolean
1758	g_desktop_app_info_load_from_keyfile (GDesktopAppInfo *info,
1759	GKeyFile *key_file)
1760	{
1761	char *start_group;
1762	char *type;
1763	char *try_exec;
1764	char *exec;
1765	gboolean bus_activatable;
1766
1767	start_group = g_key_file_get_start_group (key_file);
1768	if (start_group == NULL || strcmp (s1: start_group, G_KEY_FILE_DESKTOP_GROUP) != 0)
1769	{
1770	g_free (mem: start_group);
1771	return FALSE;
1772	}
1773	g_free (mem: start_group);
1774
1775	type = g_key_file_get_string (key_file,
1776	G_KEY_FILE_DESKTOP_GROUP,
1777	G_KEY_FILE_DESKTOP_KEY_TYPE,
1778	NULL);
1779	if (type == NULL || strcmp (s1: type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) != 0)
1780	{
1781	g_free (mem: type);
1782	return FALSE;
1783	}
1784	g_free (mem: type);
1785
1786	try_exec = g_key_file_get_string (key_file,
1787	G_KEY_FILE_DESKTOP_GROUP,
1788	G_KEY_FILE_DESKTOP_KEY_TRY_EXEC,
1789	NULL);
1790	if (try_exec && try_exec[0] != '\0')
1791	{
1792	char *t;
1793	t = g_find_program_in_path (program: try_exec);
1794	if (t == NULL)
1795	{
1796	g_free (mem: try_exec);
1797	return FALSE;
1798	}
1799	g_free (mem: t);
1800	}
1801
1802	exec = g_key_file_get_string (key_file,
1803	G_KEY_FILE_DESKTOP_GROUP,
1804	G_KEY_FILE_DESKTOP_KEY_EXEC,
1805	NULL);
1806	if (exec && exec[0] != '\0')
1807	{
1808	gint argc;
1809	char **argv;
1810	if (!g_shell_parse_argv (command_line: exec, argcp: &argc, argvp: &argv, NULL))
1811	{
1812	g_free (mem: exec);
1813	g_free (mem: try_exec);
1814	return FALSE;
1815	}
1816	else
1817	{
1818	char *t;
1819	t = g_find_program_in_path (program: argv[0]);
1820	g_strfreev (str_array: argv);
1821
1822	if (t == NULL)
1823	{
1824	g_free (mem: exec);
1825	g_free (mem: try_exec);
1826	return FALSE;
1827	}
1828	g_free (mem: t);
1829	}
1830	}
1831
1832	info->name = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NAME, NULL, NULL);
1833	info->generic_name = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, GENERIC_NAME_KEY, NULL, NULL);
1834	info->fullname = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, FULL_NAME_KEY, NULL, NULL);
1835	info->keywords = g_key_file_get_locale_string_list (key_file, G_KEY_FILE_DESKTOP_GROUP, KEYWORDS_KEY, NULL, NULL, NULL);
1836	info->comment = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_COMMENT, NULL, NULL);
1837	info->nodisplay = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, NULL) != FALSE;
1838	info->icon_name = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_ICON, NULL, NULL);
1839	info->only_show_in = g_key_file_get_string_list (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN, NULL, NULL);
1840	info->not_show_in = g_key_file_get_string_list (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN, NULL, NULL);
1841	info->try_exec = try_exec;
1842	info->exec = exec;
1843	info->path = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_PATH, NULL);
1844	info->terminal = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_TERMINAL, NULL) != FALSE;
1845	info->startup_notify = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY, NULL) != FALSE;
1846	info->no_fuse = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, key: "X-GIO-NoFuse", NULL) != FALSE;
1847	info->hidden = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_HIDDEN, NULL) != FALSE;
1848	info->categories = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_CATEGORIES, NULL);
1849	info->startup_wm_class = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, STARTUP_WM_CLASS_KEY, NULL);
1850	info->mime_types = g_key_file_get_string_list (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_MIME_TYPE, NULL, NULL);
1851	bus_activatable = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE, NULL);
1852	info->actions = g_key_file_get_string_list (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_ACTIONS, NULL, NULL);
1853
1854	/* Remove the special-case: no Actions= key just means 0 extra actions */
1855	if (info->actions == NULL)
1856	info->actions = g_new0 (gchar *, 0 + 1);
1857
1858	info->icon = NULL;
1859	if (info->icon_name)
1860	{
1861	if (g_path_is_absolute (file_name: info->icon_name))
1862	{
1863	GFile *file;
1864
1865	file = g_file_new_for_path (path: info->icon_name);
1866	info->icon = g_file_icon_new (file);
1867	g_object_unref (object: file);
1868	}
1869	else
1870	{
1871	char *p;
1872
1873	/* Work around a common mistake in desktop files */
1874	if ((p = strrchr (s: info->icon_name, c: '.')) != NULL &&
1875	(strcmp (s1: p, s2: ".png") == 0 ||
1876	strcmp (s1: p, s2: ".xpm") == 0 ||
1877	strcmp (s1: p, s2: ".svg") == 0))
1878	*p = 0;
1879
1880	info->icon = g_themed_icon_new (iconname: info->icon_name);
1881	}
1882	}
1883
1884	if (info->exec)
1885	info->binary = binary_from_exec (exec: info->exec);
1886
1887	if (info->path && info->path[0] == '\0')
1888	{
1889	g_free (mem: info->path);
1890	info->path = NULL;
1891	}
1892
1893	/* Can only be DBusActivatable if we know the filename, which means
1894	* that this won't work for the load-from-keyfile case.
1895	*/
1896	if (bus_activatable && info->filename)
1897	{
1898	gchar *basename;
1899	gchar *last_dot;
1900
1901	basename = g_path_get_basename (file_name: info->filename);
1902	last_dot = strrchr (s: basename, c: '.');
1903
1904	if (last_dot && g_str_equal (v1: last_dot, v2: ".desktop"))
1905	{
1906	*last_dot = '\0';
1907
1908	if (g_dbus_is_name (string: basename) && basename[0] != ':')
1909	info->app_id = g_strdup (str: basename);
1910	}
1911
1912	g_free (mem: basename);
1913	}
1914
1915	info->keyfile = g_key_file_ref (key_file);
1916
1917	return TRUE;
1918	}
1919
1920	static gboolean
1921	g_desktop_app_info_load_file (GDesktopAppInfo *self)
1922	{
1923	GKeyFile *key_file;
1924	gboolean retval = FALSE;
1925
1926	g_return_val_if_fail (self->filename != NULL, FALSE);
1927
1928	self->desktop_id = g_path_get_basename (file_name: self->filename);
1929
1930	key_file = g_key_file_new ();
1931
1932	if (g_key_file_load_from_file (key_file, file: self->filename, flags: G_KEY_FILE_NONE, NULL))
1933	retval = g_desktop_app_info_load_from_keyfile (info: self, key_file);
1934
1935	g_key_file_unref (key_file);
1936	return retval;
1937	}
1938
1939	/**
1940	* g_desktop_app_info_new_from_keyfile:
1941	* @key_file: an opened #GKeyFile
1942	*
1943	* Creates a new #GDesktopAppInfo.
1944	*
1945	* Returns: (nullable): a new #GDesktopAppInfo or %NULL on error.
1946	*
1947	* Since: 2.18
1948	**/
1949	GDesktopAppInfo *
1950	g_desktop_app_info_new_from_keyfile (GKeyFile *key_file)
1951	{
1952	GDesktopAppInfo *info;
1953
1954	info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
1955	info->filename = NULL;
1956	if (!g_desktop_app_info_load_from_keyfile (info, key_file))
1957	{
1958	g_object_unref (object: info);
1959	return NULL;
1960	}
1961	return info;
1962	}
1963
1964	/**
1965	* g_desktop_app_info_new_from_filename:
1966	* @filename: (type filename): the path of a desktop file, in the GLib
1967	* filename encoding
1968	*
1969	* Creates a new #GDesktopAppInfo.
1970	*
1971	* Returns: (nullable): a new #GDesktopAppInfo or %NULL on error.
1972	**/
1973	GDesktopAppInfo *
1974	g_desktop_app_info_new_from_filename (const char *filename)
1975	{
1976	GDesktopAppInfo *info = NULL;
1977
1978	info = g_object_new (G_TYPE_DESKTOP_APP_INFO, first_property_name: "filename", filename, NULL);
1979	if (!g_desktop_app_info_load_file (self: info))
1980	{
1981	g_object_unref (object: info);
1982	return NULL;
1983	}
1984	return info;
1985	}
1986
1987	/**
1988	* g_desktop_app_info_new:
1989	* @desktop_id: the desktop file id
1990	*
1991	* Creates a new #GDesktopAppInfo based on a desktop file id.
1992	*
1993	* A desktop file id is the basename of the desktop file, including the
1994	* .desktop extension. GIO is looking for a desktop file with this name
1995	* in the `applications` subdirectories of the XDG
1996	* data directories (i.e. the directories specified in the `XDG_DATA_HOME`
1997	* and `XDG_DATA_DIRS` environment variables). GIO also supports the
1998	* prefix-to-subdirectory mapping that is described in the
1999	* [Menu Spec](http://standards.freedesktop.org/menu-spec/latest/)
2000	* (i.e. a desktop id of kde-foo.desktop will match
2001	* `/usr/share/applications/kde/foo.desktop`).
2002	*
2003	* Returns: (nullable): a new #GDesktopAppInfo, or %NULL if no desktop
2004	* file with that id exists.
2005	*/
2006	GDesktopAppInfo *
2007	g_desktop_app_info_new (const char *desktop_id)
2008	{
2009	GDesktopAppInfo *appinfo = NULL;
2010	guint i;
2011
2012	desktop_file_dirs_lock ();
2013
2014	for (i = 0; i < desktop_file_dirs->len; i++)
2015	{
2016	appinfo = desktop_file_dir_get_app (g_ptr_array_index (desktop_file_dirs, i), desktop_id);
2017
2018	if (appinfo)
2019	break;
2020	}
2021
2022	desktop_file_dirs_unlock ();
2023
2024	if (appinfo == NULL)
2025	return NULL;
2026
2027	g_free (mem: appinfo->desktop_id);
2028	appinfo->desktop_id = g_strdup (str: desktop_id);
2029
2030	if (g_desktop_app_info_get_is_hidden (info: appinfo))
2031	{
2032	g_object_unref (object: appinfo);
2033	appinfo = NULL;
2034	}
2035
2036	return appinfo;
2037	}
2038
2039	static GAppInfo *
2040	g_desktop_app_info_dup (GAppInfo *appinfo)
2041	{
2042	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2043	GDesktopAppInfo *new_info;
2044
2045	new_info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
2046
2047	new_info->filename = g_strdup (str: info->filename);
2048	new_info->desktop_id = g_strdup (str: info->desktop_id);
2049
2050	if (info->keyfile)
2051	new_info->keyfile = g_key_file_ref (key_file: info->keyfile);
2052
2053	new_info->name = g_strdup (str: info->name);
2054	new_info->generic_name = g_strdup (str: info->generic_name);
2055	new_info->fullname = g_strdup (str: info->fullname);
2056	new_info->keywords = g_strdupv (str_array: info->keywords);
2057	new_info->comment = g_strdup (str: info->comment);
2058	new_info->nodisplay = info->nodisplay;
2059	new_info->icon_name = g_strdup (str: info->icon_name);
2060	if (info->icon)
2061	new_info->icon = g_object_ref (info->icon);
2062	new_info->only_show_in = g_strdupv (str_array: info->only_show_in);
2063	new_info->not_show_in = g_strdupv (str_array: info->not_show_in);
2064	new_info->try_exec = g_strdup (str: info->try_exec);
2065	new_info->exec = g_strdup (str: info->exec);
2066	new_info->binary = g_strdup (str: info->binary);
2067	new_info->path = g_strdup (str: info->path);
2068	new_info->app_id = g_strdup (str: info->app_id);
2069	new_info->hidden = info->hidden;
2070	new_info->terminal = info->terminal;
2071	new_info->startup_notify = info->startup_notify;
2072
2073	return G_APP_INFO (new_info);
2074	}
2075
2076	/* GAppInfo interface implementation functions {{{2 */
2077
2078	static gboolean
2079	g_desktop_app_info_equal (GAppInfo *appinfo1,
2080	GAppInfo *appinfo2)
2081	{
2082	GDesktopAppInfo *info1 = G_DESKTOP_APP_INFO (appinfo1);
2083	GDesktopAppInfo *info2 = G_DESKTOP_APP_INFO (appinfo2);
2084
2085	if (info1->desktop_id == NULL ||
2086	info2->desktop_id == NULL)
2087	return info1 == info2;
2088
2089	return strcmp (s1: info1->desktop_id, s2: info2->desktop_id) == 0;
2090	}
2091
2092	static const char *
2093	g_desktop_app_info_get_id (GAppInfo *appinfo)
2094	{
2095	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2096
2097	return info->desktop_id;
2098	}
2099
2100	static const char *
2101	g_desktop_app_info_get_name (GAppInfo *appinfo)
2102	{
2103	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2104
2105	if (info->name == NULL)
2106	return _("Unnamed");
2107	return info->name;
2108	}
2109
2110	static const char *
2111	g_desktop_app_info_get_display_name (GAppInfo *appinfo)
2112	{
2113	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2114
2115	if (info->fullname == NULL)
2116	return g_desktop_app_info_get_name (appinfo);
2117	return info->fullname;
2118	}
2119
2120	/**
2121	* g_desktop_app_info_get_is_hidden:
2122	* @info: a #GDesktopAppInfo.
2123	*
2124	* A desktop file is hidden if the Hidden key in it is
2125	* set to True.
2126	*
2127	* Returns: %TRUE if hidden, %FALSE otherwise.
2128	**/
2129	gboolean
2130	g_desktop_app_info_get_is_hidden (GDesktopAppInfo *info)
2131	{
2132	return info->hidden;
2133	}
2134
2135	/**
2136	* g_desktop_app_info_get_filename:
2137	* @info: a #GDesktopAppInfo
2138	*
2139	* When @info was created from a known filename, return it. In some
2140	* situations such as the #GDesktopAppInfo returned from
2141	* g_desktop_app_info_new_from_keyfile(), this function will return %NULL.
2142	*
2143	* Returns: (nullable) (type filename): The full path to the file for @info,
2144	* or %NULL if not known.
2145	* Since: 2.24
2146	*/
2147	const char *
2148	g_desktop_app_info_get_filename (GDesktopAppInfo *info)
2149	{
2150	return info->filename;
2151	}
2152
2153	static const char *
2154	g_desktop_app_info_get_description (GAppInfo *appinfo)
2155	{
2156	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2157
2158	return info->comment;
2159	}
2160
2161	static const char *
2162	g_desktop_app_info_get_executable (GAppInfo *appinfo)
2163	{
2164	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2165
2166	return info->binary;
2167	}
2168
2169	static const char *
2170	g_desktop_app_info_get_commandline (GAppInfo *appinfo)
2171	{
2172	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2173
2174	return info->exec;
2175	}
2176
2177	static GIcon *
2178	g_desktop_app_info_get_icon (GAppInfo *appinfo)
2179	{
2180	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
2181
2182	return info->icon;
2183	}
2184
2185	/**
2186	* g_desktop_app_info_get_categories:
2187	* @info: a #GDesktopAppInfo
2188	*
2189	* Gets the categories from the desktop file.
2190	*
2191	* Returns: (nullable): The unparsed Categories key from the desktop file;
2192	* i.e. no attempt is made to split it by ';' or validate it.
2193	*/
2194	const char *
2195	g_desktop_app_info_get_categories (GDesktopAppInfo *info)
2196	{
2197	return info->categories;
2198	}
2199
2200	/**
2201	* g_desktop_app_info_get_keywords:
2202	* @info: a #GDesktopAppInfo
2203	*
2204	* Gets the keywords from the desktop file.
2205	*
2206	* Returns: (transfer none): The value of the Keywords key
2207	*
2208	* Since: 2.32
2209	*/
2210	const char * const *
2211	g_desktop_app_info_get_keywords (GDesktopAppInfo *info)
2212	{
2213	return (const char * const *)info->keywords;
2214	}
2215
2216	/**
2217	* g_desktop_app_info_get_generic_name:
2218	* @info: a #GDesktopAppInfo
2219	*
2220	* Gets the generic name from the desktop file.
2221	*
2222	* Returns: (nullable): The value of the GenericName key
2223	*/
2224	const char *
2225	g_desktop_app_info_get_generic_name (GDesktopAppInfo *info)
2226	{
2227	return info->generic_name;
2228	}
2229
2230	/**
2231	* g_desktop_app_info_get_nodisplay:
2232	* @info: a #GDesktopAppInfo
2233	*
2234	* Gets the value of the NoDisplay key, which helps determine if the
2235	* application info should be shown in menus. See
2236	* #G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY and g_app_info_should_show().
2237	*
2238	* Returns: The value of the NoDisplay key
2239	*
2240	* Since: 2.30
2241	*/
2242	gboolean
2243	g_desktop_app_info_get_nodisplay (GDesktopAppInfo *info)
2244	{
2245	return info->nodisplay;
2246	}
2247
2248	/**
2249	* g_desktop_app_info_get_show_in:
2250	* @info: a #GDesktopAppInfo
2251	* @desktop_env: (nullable): a string specifying a desktop name
2252	*
2253	* Checks if the application info should be shown in menus that list available
2254	* applications for a specific name of the desktop, based on the
2255	* `OnlyShowIn` and `NotShowIn` keys.
2256	*
2257	* @desktop_env should typically be given as %NULL, in which case the
2258	* `XDG_CURRENT_DESKTOP` environment variable is consulted. If you want
2259	* to override the default mechanism then you may specify @desktop_env,
2260	* but this is not recommended.
2261	*
2262	* Note that g_app_info_should_show() for @info will include this check (with
2263	* %NULL for @desktop_env) as well as additional checks.
2264	*
2265	* Returns: %TRUE if the @info should be shown in @desktop_env according to the
2266	* `OnlyShowIn` and `NotShowIn` keys, %FALSE
2267	* otherwise.
2268	*
2269	* Since: 2.30
2270	*/
2271	gboolean
2272	g_desktop_app_info_get_show_in (GDesktopAppInfo *info,
2273	const gchar *desktop_env)
2274	{
2275	const gchar *specified_envs[] = { desktop_env, NULL };
2276	const gchar * const *envs;
2277	gint i;
2278
2279	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), FALSE);
2280
2281	if (desktop_env)
2282	envs = specified_envs;
2283	else
2284	envs = get_current_desktops (NULL);
2285
2286	for (i = 0; envs[i]; i++)
2287	{
2288	gint j;
2289
2290	if (info->only_show_in)
2291	for (j = 0; info->only_show_in[j]; j++)
2292	if (g_str_equal (v1: info->only_show_in[j], v2: envs[i]))
2293	return TRUE;
2294
2295	if (info->not_show_in)
2296	for (j = 0; info->not_show_in[j]; j++)
2297	if (g_str_equal (v1: info->not_show_in[j], v2: envs[i]))
2298	return FALSE;
2299	}
2300
2301	return info->only_show_in == NULL;
2302	}
2303
2304	/* Launching... {{{2 */
2305
2306	static char *
2307	expand_macro_single (char macro, const char *uri)
2308	{
2309	GFile *file;
2310	char *result = NULL;
2311	char *path = NULL;
2312	char *name;
2313
2314	file = g_file_new_for_uri (uri);
2315
2316	switch (macro)
2317	{
2318	case 'u':
2319	case 'U':
2320	result = g_shell_quote (unquoted_string: uri);
2321	break;
2322	case 'f':
2323	case 'F':
2324	path = g_file_get_path (file);
2325	if (path)
2326	result = g_shell_quote (unquoted_string: path);
2327	break;
2328	case 'd':
2329	case 'D':
2330	path = g_file_get_path (file);
2331	if (path)
2332	{
2333	name = g_path_get_dirname (file_name: path);
2334	result = g_shell_quote (unquoted_string: name);
2335	g_free (mem: name);
2336	}
2337	break;
2338	case 'n':
2339	case 'N':
2340	path = g_file_get_path (file);
2341	if (path)
2342	{
2343	name = g_path_get_basename (file_name: path);
2344	result = g_shell_quote (unquoted_string: name);
2345	g_free (mem: name);
2346	}
2347	break;
2348	}
2349
2350	g_object_unref (object: file);
2351	g_free (mem: path);
2352
2353	return result;
2354	}
2355
2356	static char *
2357	expand_macro_uri (char macro, const char *uri, gboolean force_file_uri, char force_file_uri_macro)
2358	{
2359	char *expanded = NULL;
2360
2361	g_return_val_if_fail (uri != NULL, NULL);
2362
2363	if (!force_file_uri ||
2364	/* Pass URI if it contains an anchor */
2365	strchr (s: uri, c: '#') != NULL)
2366	{
2367	expanded = expand_macro_single (macro, uri);
2368	}
2369	else
2370	{
2371	expanded = expand_macro_single (macro: force_file_uri_macro, uri);
2372	if (expanded == NULL)
2373	expanded = expand_macro_single (macro, uri);
2374	}
2375
2376	return expanded;
2377	}
2378
2379	static void
2380	expand_macro (char macro,
2381	GString *exec,
2382	GDesktopAppInfo *info,
2383	GList **uri_list)
2384	{
2385	GList *uris = *uri_list;
2386	char *expanded = NULL;
2387	gboolean force_file_uri;
2388	char force_file_uri_macro;
2389	const char *uri;
2390
2391	g_return_if_fail (exec != NULL);
2392
2393	/* On %u and %U, pass POSIX file path pointing to the URI via
2394	* the FUSE mount in ~/.gvfs. Note that if the FUSE daemon isn't
2395	* running or the URI doesn't have a POSIX file path via FUSE
2396	* we'll just pass the URI.
2397	*/
2398	force_file_uri_macro = macro;
2399	force_file_uri = FALSE;
2400	if (!info->no_fuse)
2401	{
2402	switch (macro)
2403	{
2404	case 'u':
2405	force_file_uri_macro = 'f';
2406	force_file_uri = TRUE;
2407	break;
2408	case 'U':
2409	force_file_uri_macro = 'F';
2410	force_file_uri = TRUE;
2411	break;
2412	default:
2413	break;
2414	}
2415	}
2416
2417	switch (macro)
2418	{
2419	case 'u':
2420	case 'f':
2421	case 'd':
2422	case 'n':
2423	if (uris)
2424	{
2425	uri = uris->data;
2426	expanded = expand_macro_uri (macro, uri,
2427	force_file_uri, force_file_uri_macro);
2428	if (expanded)
2429	{
2430	g_string_append (string: exec, val: expanded);
2431	g_free (mem: expanded);
2432	}
2433	uris = uris->next;
2434	}
2435
2436	break;
2437
2438	case 'U':
2439	case 'F':
2440	case 'D':
2441	case 'N':
2442	while (uris)
2443	{
2444	uri = uris->data;
2445	expanded = expand_macro_uri (macro, uri,
2446	force_file_uri, force_file_uri_macro);
2447	if (expanded)
2448	{
2449	g_string_append (string: exec, val: expanded);
2450	g_free (mem: expanded);
2451	}
2452
2453	uris = uris->next;
2454
2455	if (uris != NULL && expanded)
2456	g_string_append_c (exec, ' ');
2457	}
2458
2459	break;
2460
2461	case 'i':
2462	if (info->icon_name)
2463	{
2464	g_string_append (string: exec, val: "--icon ");
2465	expanded = g_shell_quote (unquoted_string: info->icon_name);
2466	g_string_append (string: exec, val: expanded);
2467	g_free (mem: expanded);
2468	}
2469	break;
2470
2471	case 'c':
2472	if (info->name)
2473	{
2474	expanded = g_shell_quote (unquoted_string: info->name);
2475	g_string_append (string: exec, val: expanded);
2476	g_free (mem: expanded);
2477	}
2478	break;
2479
2480	case 'k':
2481	if (info->filename)
2482	{
2483	expanded = g_shell_quote (unquoted_string: info->filename);
2484	g_string_append (string: exec, val: expanded);
2485	g_free (mem: expanded);
2486	}
2487	break;
2488
2489	case 'm': /* deprecated */
2490	break;
2491
2492	case '%':
2493	g_string_append_c (exec, '%');
2494	break;
2495	}
2496
2497	*uri_list = uris;
2498	}
2499
2500	static gboolean
2501	expand_application_parameters (GDesktopAppInfo *info,
2502	const gchar *exec_line,
2503	GList **uris,
2504	int *argc,
2505	char ***argv,
2506	GError **error)
2507	{
2508	GList *uri_list = *uris;
2509	const char *p = exec_line;
2510	GString *expanded_exec;
2511	gboolean res;
2512
2513	if (exec_line == NULL)
2514	{
2515	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
2516	_("Desktop file didn’t specify Exec field"));
2517	return FALSE;
2518	}
2519
2520	expanded_exec = g_string_new (NULL);
2521
2522	while (*p)
2523	{
2524	if (p[0] == '%' && p[1] != '\0')
2525	{
2526	expand_macro (macro: p[1], exec: expanded_exec, info, uri_list: uris);
2527	p++;
2528	}
2529	else
2530	g_string_append_c (expanded_exec, *p);
2531
2532	p++;
2533	}
2534
2535	/* No file substitutions */
2536	if (uri_list == *uris && uri_list != NULL)
2537	{
2538	/* If there is no macro default to %f. This is also what KDE does */
2539	g_string_append_c (expanded_exec, ' ');
2540	expand_macro (macro: 'f', exec: expanded_exec, info, uri_list: uris);
2541	}
2542
2543	res = g_shell_parse_argv (command_line: expanded_exec->str, argcp: argc, argvp: argv, error);
2544	g_string_free (string: expanded_exec, TRUE);
2545	return res;
2546	}
2547
2548	static gboolean
2549	prepend_terminal_to_vector (int *argc,
2550	char ***argv)
2551	{
2552	#ifndef G_OS_WIN32
2553	char **real_argv;
2554	int real_argc;
2555	int i, j;
2556	char **term_argv = NULL;
2557	int term_argc = 0;
2558	char *check;
2559	char **the_argv;
2560
2561	g_return_val_if_fail (argc != NULL, FALSE);
2562	g_return_val_if_fail (argv != NULL, FALSE);
2563
2564	/* sanity */
2565	if(*argv == NULL)
2566	*argc = 0;
2567
2568	the_argv = *argv;
2569
2570	/* compute size if not given */
2571	if (*argc < 0)
2572	{
2573	for (i = 0; the_argv[i] != NULL; i++)
2574	;
2575	*argc = i;
2576	}
2577
2578	term_argc = 2;
2579	term_argv = g_new0 (char *, 3);
2580
2581	check = g_find_program_in_path (program: "gnome-terminal");
2582	if (check != NULL)
2583	{
2584	term_argv[0] = check;
2585	/* Since 2017, gnome-terminal has preferred `--` over `-x` or `-e`. */
2586	term_argv[1] = g_strdup (str: "--");
2587	}
2588	else
2589	{
2590	if (check == NULL)
2591	check = g_find_program_in_path (program: "mate-terminal");
2592	if (check == NULL)
2593	check = g_find_program_in_path (program: "xfce4-terminal");
2594	if (check != NULL)
2595	{
2596	term_argv[0] = check;
2597	/* Note that gnome-terminal takes -x and
2598	* as -e in gnome-terminal is broken we use that. */
2599	term_argv[1] = g_strdup (str: "-x");
2600	}
2601	else
2602	{
2603	if (check == NULL)
2604	check = g_find_program_in_path (program: "tilix");
2605	if (check == NULL)
2606	check = g_find_program_in_path (program: "konsole");
2607	if (check == NULL)
2608	check = g_find_program_in_path (program: "nxterm");
2609	if (check == NULL)
2610	check = g_find_program_in_path (program: "color-xterm");
2611	if (check == NULL)
2612	check = g_find_program_in_path (program: "rxvt");
2613	if (check == NULL)
2614	check = g_find_program_in_path (program: "dtterm");
2615	if (check == NULL)
2616	{
2617	check = g_strdup (str: "xterm");
2618	g_debug ("Couldn’t find a terminal: falling back to xterm");
2619	}
2620	term_argv[0] = check;
2621	term_argv[1] = g_strdup (str: "-e");
2622	}
2623	}
2624
2625	real_argc = term_argc + *argc;
2626	real_argv = g_new (char *, real_argc + 1);
2627
2628	for (i = 0; i < term_argc; i++)
2629	real_argv[i] = term_argv[i];
2630
2631	for (j = 0; j < *argc; j++, i++)
2632	real_argv[i] = (char *)the_argv[j];
2633
2634	real_argv[i] = NULL;
2635
2636	g_free (mem: *argv);
2637	*argv = real_argv;
2638	*argc = real_argc;
2639
2640	/* we use g_free here as we sucked all the inner strings
2641	* out from it into real_argv */
2642	g_free (mem: term_argv);
2643	return TRUE;
2644	#else
2645	return FALSE;
2646	#endif /* G_OS_WIN32 */
2647	}
2648
2649	static GList *
2650	create_files_for_uris (GList *uris)
2651	{
2652	GList *res;
2653	GList *iter;
2654
2655	res = NULL;
2656
2657	for (iter = uris; iter; iter = iter->next)
2658	{
2659	GFile *file = g_file_new_for_uri (uri: (char *)iter->data);
2660	res = g_list_prepend (list: res, data: file);
2661	}
2662
2663	return g_list_reverse (list: res);
2664	}
2665
2666	static void
2667	notify_desktop_launch (GDBusConnection *session_bus,
2668	GDesktopAppInfo *info,
2669	long pid,
2670	const char *display,
2671	const char *sn_id,
2672	GList *uris)
2673	{
2674	GDBusMessage *msg;
2675	GVariantBuilder uri_variant;
2676	GVariantBuilder extras_variant;
2677	GList *iter;
2678	const char *desktop_file_id;
2679	const char *gio_desktop_file;
2680
2681	if (session_bus == NULL)
2682	return;
2683
2684	g_variant_builder_init (builder: &uri_variant, G_VARIANT_TYPE ("as"));
2685	for (iter = uris; iter; iter = iter->next)
2686	g_variant_builder_add (builder: &uri_variant, format_string: "s", iter->data);
2687
2688	g_variant_builder_init (builder: &extras_variant, G_VARIANT_TYPE ("a{sv}"));
2689	if (sn_id != NULL && g_utf8_validate (str: sn_id, max_len: -1, NULL))
2690	g_variant_builder_add (builder: &extras_variant, format_string: "{sv}",
2691	"startup-id",
2692	g_variant_new (format_string: "s",
2693	sn_id));
2694	gio_desktop_file = g_getenv (variable: "GIO_LAUNCHED_DESKTOP_FILE");
2695	if (gio_desktop_file != NULL)
2696	g_variant_builder_add (builder: &extras_variant, format_string: "{sv}",
2697	"origin-desktop-file",
2698	g_variant_new_bytestring (string: gio_desktop_file));
2699	if (g_get_prgname () != NULL)
2700	g_variant_builder_add (builder: &extras_variant, format_string: "{sv}",
2701	"origin-prgname",
2702	g_variant_new_bytestring (string: g_get_prgname ()));
2703	g_variant_builder_add (builder: &extras_variant, format_string: "{sv}",
2704	"origin-pid",
2705	g_variant_new (format_string: "x",
2706	(gint64)getpid ()));
2707
2708	if (info->filename)
2709	desktop_file_id = info->filename;
2710	else if (info->desktop_id)
2711	desktop_file_id = info->desktop_id;
2712	else
2713	desktop_file_id = "";
2714
2715	msg = g_dbus_message_new_signal (path: "/org/gtk/gio/DesktopAppInfo",
2716	interface_: "org.gtk.gio.DesktopAppInfo",
2717	signal: "Launched");
2718	g_dbus_message_set_body (message: msg, body: g_variant_new (format_string: "(@aysxasa{sv})",
2719	g_variant_new_bytestring (string: desktop_file_id),
2720	display ? display : "",
2721	(gint64)pid,
2722	&uri_variant,
2723	&extras_variant));
2724	g_dbus_connection_send_message (connection: session_bus,
2725	message: msg, flags: 0,
2726	NULL,
2727	NULL);
2728	g_object_unref (object: msg);
2729	}
2730
2731	#define _SPAWN_FLAGS_DEFAULT (G_SPAWN_SEARCH_PATH)
2732
2733	static gboolean
2734	g_desktop_app_info_launch_uris_with_spawn (GDesktopAppInfo *info,
2735	GDBusConnection *session_bus,
2736	const gchar *exec_line,
2737	GList *uris,
2738	GAppLaunchContext *launch_context,
2739	GSpawnFlags spawn_flags,
2740	GSpawnChildSetupFunc user_setup,
2741	gpointer user_setup_data,
2742	GDesktopAppLaunchCallback pid_callback,
2743	gpointer pid_callback_data,
2744	gint stdin_fd,
2745	gint stdout_fd,
2746	gint stderr_fd,
2747	GError **error)
2748	{
2749	gboolean completed = FALSE;
2750	GList *old_uris;
2751	GList *dup_uris;
2752
2753	char **argv, **envp;
2754	int argc;
2755
2756	g_return_val_if_fail (info != NULL, FALSE);
2757
2758	argv = NULL;
2759
2760	if (launch_context)
2761	envp = g_app_launch_context_get_environment (context: launch_context);
2762	else
2763	envp = g_get_environ ();
2764
2765	/* The GList* passed to expand_application_parameters() will be modified
2766	* internally by expand_macro(), so we need to pass a copy of it instead,
2767	* and also use that copy to control the exit condition of the loop below.
2768	*/
2769	dup_uris = uris;
2770	do
2771	{
2772	GPid pid;
2773	GList *launched_uris;
2774	GList *iter;
2775	char *sn_id = NULL;
2776	char **wrapped_argv;
2777	int i;
2778	gsize j;
2779	const gchar * const wrapper_argv[] =
2780	{
2781	"/bin/sh",
2782	"-e",
2783	"-u",
2784	"-c", "export GIO_LAUNCHED_DESKTOP_FILE_PID=$$; exec \"$@\"",
2785	"sh", /* argv[0] for sh */
2786	};
2787
2788	old_uris = dup_uris;
2789	if (!expand_application_parameters (info, exec_line, uris: &dup_uris, argc: &argc, argv: &argv, error))
2790	goto out;
2791
2792	/* Get the subset of URIs we're launching with this process */
2793	launched_uris = NULL;
2794	for (iter = old_uris; iter != NULL && iter != dup_uris; iter = iter->next)
2795	launched_uris = g_list_prepend (list: launched_uris, data: iter->data);
2796	launched_uris = g_list_reverse (list: launched_uris);
2797
2798	if (info->terminal && !prepend_terminal_to_vector (argc: &argc, argv: &argv))
2799	{
2800	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
2801	_("Unable to find terminal required for application"));
2802	goto out;
2803	}
2804
2805	if (info->filename)
2806	envp = g_environ_setenv (envp,
2807	variable: "GIO_LAUNCHED_DESKTOP_FILE",
2808	value: info->filename,
2809	TRUE);
2810
2811	sn_id = NULL;
2812	if (launch_context)
2813	{
2814	GList *launched_files = create_files_for_uris (uris: launched_uris);
2815
2816	if (info->startup_notify)
2817	{
2818	sn_id = g_app_launch_context_get_startup_notify_id (context: launch_context,
2819	G_APP_INFO (info),
2820	files: launched_files);
2821	if (sn_id)
2822	envp = g_environ_setenv (envp, variable: "DESKTOP_STARTUP_ID", value: sn_id, TRUE);
2823	}
2824
2825	g_list_free_full (list: launched_files, free_func: g_object_unref);
2826	}
2827
2828	/* Wrap the @argv in a command which will set the
2829	* `GIO_LAUNCHED_DESKTOP_FILE_PID` environment variable. We can’t set this
2830	* in @envp along with `GIO_LAUNCHED_DESKTOP_FILE` because we need to know
2831	* the PID of the new forked process. We can’t use setenv() between fork()
2832	* and exec() because we’d rather use posix_spawn() for speed.
2833	*
2834	* `sh` should be available on all the platforms that `GDesktopAppInfo`
2835	* currently supports (since they are all POSIX). If additional platforms
2836	* need to be supported in future, it will probably have to be replaced
2837	* with a wrapper program (grep the GLib git history for
2838	* `gio-launch-desktop` for an example of this which could be
2839	* resurrected). */
2840	wrapped_argv = g_new (char *, argc + G_N_ELEMENTS (wrapper_argv) + 1);
2841
2842	for (j = 0; j < G_N_ELEMENTS (wrapper_argv); j++)
2843	wrapped_argv[j] = g_strdup (str: wrapper_argv[j]);
2844	for (i = 0; i < argc; i++)
2845	wrapped_argv[i + G_N_ELEMENTS (wrapper_argv)] = g_steal_pointer (&argv[i]);
2846
2847	wrapped_argv[i + G_N_ELEMENTS (wrapper_argv)] = NULL;
2848	g_free (mem: argv);
2849	argv = NULL;
2850
2851	if (!g_spawn_async_with_fds (working_directory: info->path,
2852	argv: wrapped_argv,
2853	envp,
2854	flags: spawn_flags,
2855	child_setup: user_setup,
2856	user_data: user_setup_data,
2857	child_pid: &pid,
2858	stdin_fd,
2859	stdout_fd,
2860	stderr_fd,
2861	error))
2862	{
2863	if (sn_id)
2864	g_app_launch_context_launch_failed (context: launch_context, startup_notify_id: sn_id);
2865
2866	g_free (mem: sn_id);
2867	g_list_free (list: launched_uris);
2868
2869	goto out;
2870	}
2871
2872	if (pid_callback != NULL)
2873	pid_callback (info, pid, pid_callback_data);
2874
2875	if (launch_context != NULL)
2876	{
2877	GVariantBuilder builder;
2878	GVariant *platform_data;
2879
2880	g_variant_builder_init (builder: &builder, G_VARIANT_TYPE_ARRAY);
2881	g_variant_builder_add (builder: &builder, format_string: "{sv}", "pid", g_variant_new_int32 (value: pid));
2882	if (sn_id)
2883	g_variant_builder_add (builder: &builder, format_string: "{sv}", "startup-notification-id", g_variant_new_string (string: sn_id));
2884	platform_data = g_variant_ref_sink (value: g_variant_builder_end (builder: &builder));
2885	g_signal_emit_by_name (instance: launch_context, detailed_signal: "launched", info, platform_data);
2886	g_variant_unref (value: platform_data);
2887	}
2888
2889	notify_desktop_launch (session_bus,
2890	info,
2891	pid,
2892	NULL,
2893	sn_id,
2894	uris: launched_uris);
2895
2896	g_free (mem: sn_id);
2897	g_list_free (list: launched_uris);
2898
2899	g_strfreev (str_array: wrapped_argv);
2900	wrapped_argv = NULL;
2901	}
2902	while (dup_uris != NULL);
2903
2904	completed = TRUE;
2905
2906	out:
2907	g_strfreev (str_array: argv);
2908	g_strfreev (str_array: envp);
2909
2910	return completed;
2911	}
2912
2913	static gchar *
2914	object_path_from_appid (const gchar *appid)
2915	{
2916	gchar *appid_path, *iter;
2917
2918	appid_path = g_strconcat (string1: "/", appid, NULL);
2919	for (iter = appid_path; *iter; iter++)
2920	{
2921	if (*iter == '.')
2922	*iter = '/';
2923
2924	if (*iter == '-')
2925	*iter = '_';
2926	}
2927
2928	return appid_path;
2929	}
2930
2931	static GVariant *
2932	g_desktop_app_info_make_platform_data (GDesktopAppInfo *info,
2933	GList *uris,
2934	GAppLaunchContext *launch_context)
2935	{
2936	GVariantBuilder builder;
2937
2938	g_variant_builder_init (builder: &builder, G_VARIANT_TYPE_VARDICT);
2939
2940	if (launch_context)
2941	{
2942	GList *launched_files = create_files_for_uris (uris);
2943
2944	if (info->startup_notify)
2945	{
2946	gchar *sn_id;
2947
2948	sn_id = g_app_launch_context_get_startup_notify_id (context: launch_context, G_APP_INFO (info), files: launched_files);
2949	if (sn_id)
2950	g_variant_builder_add (builder: &builder, format_string: "{sv}", "desktop-startup-id", g_variant_new_take_string (string: sn_id));
2951	}
2952
2953	g_list_free_full (list: launched_files, free_func: g_object_unref);
2954	}
2955
2956	return g_variant_builder_end (builder: &builder);
2957	}
2958
2959	static void
2960	launch_uris_with_dbus (GDesktopAppInfo *info,
2961	GDBusConnection *session_bus,
2962	GList *uris,
2963	GAppLaunchContext *launch_context,
2964	GCancellable *cancellable,
2965	GAsyncReadyCallback callback,
2966	gpointer user_data)
2967	{
2968	GVariantBuilder builder;
2969	gchar *object_path;
2970
2971	g_variant_builder_init (builder: &builder, G_VARIANT_TYPE_TUPLE);
2972
2973	if (uris)
2974	{
2975	GList *iter;
2976
2977	g_variant_builder_open (builder: &builder, G_VARIANT_TYPE_STRING_ARRAY);
2978	for (iter = uris; iter; iter = iter->next)
2979	g_variant_builder_add (builder: &builder, format_string: "s", iter->data);
2980	g_variant_builder_close (builder: &builder);
2981	}
2982
2983	g_variant_builder_add_value (builder: &builder, value: g_desktop_app_info_make_platform_data (info, uris, launch_context));
2984
2985	object_path = object_path_from_appid (appid: info->app_id);
2986	g_dbus_connection_call (connection: session_bus, bus_name: info->app_id, object_path, interface_name: "org.freedesktop.Application",
2987	method_name: uris ? "Open" : "Activate", parameters: g_variant_builder_end (builder: &builder),
2988	NULL, flags: G_DBUS_CALL_FLAGS_NONE, timeout_msec: -1,
2989	cancellable, callback, user_data);
2990	g_free (mem: object_path);
2991	}
2992
2993	static gboolean
2994	g_desktop_app_info_launch_uris_with_dbus (GDesktopAppInfo *info,
2995	GDBusConnection *session_bus,
2996	GList *uris,
2997	GAppLaunchContext *launch_context,
2998	GCancellable *cancellable,
2999	GAsyncReadyCallback callback,
3000	gpointer user_data)
3001	{
3002	GList *ruris = uris;
3003	char *app_id = NULL;
3004
3005	g_return_val_if_fail (info != NULL, FALSE);
3006
3007	#ifdef G_OS_UNIX
3008	app_id = g_desktop_app_info_get_string (info, key: "X-Flatpak");
3009	if (app_id && *app_id)
3010	{
3011	ruris = g_document_portal_add_documents (uris, app_id, NULL);
3012	if (ruris == NULL)
3013	ruris = uris;
3014	}
3015	#endif
3016
3017	launch_uris_with_dbus (info, session_bus, uris: ruris, launch_context,
3018	cancellable, callback, user_data);
3019
3020	if (ruris != uris)
3021	g_list_free_full (list: ruris, free_func: g_free);
3022
3023	g_free (mem: app_id);
3024
3025	return TRUE;
3026	}
3027
3028	static gboolean
3029	g_desktop_app_info_launch_uris_internal (GAppInfo *appinfo,
3030	GList *uris,
3031	GAppLaunchContext *launch_context,
3032	GSpawnFlags spawn_flags,
3033	GSpawnChildSetupFunc user_setup,
3034	gpointer user_setup_data,
3035	GDesktopAppLaunchCallback pid_callback,
3036	gpointer pid_callback_data,
3037	gint stdin_fd,
3038	gint stdout_fd,
3039	gint stderr_fd,
3040	GError **error)
3041	{
3042	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3043	GDBusConnection *session_bus;
3044	gboolean success = TRUE;
3045
3046	session_bus = g_bus_get_sync (bus_type: G_BUS_TYPE_SESSION, NULL, NULL);
3047
3048	if (session_bus && info->app_id)
3049	/* This is non-blocking API. Similar to launching via fork()/exec()
3050	* we don't wait around to see if the program crashed during startup.
3051	* This is what startup-notification's job is...
3052	*/
3053	g_desktop_app_info_launch_uris_with_dbus (info, session_bus, uris, launch_context,
3054	NULL, NULL, NULL);
3055	else
3056	success = g_desktop_app_info_launch_uris_with_spawn (info, session_bus, exec_line: info->exec, uris, launch_context,
3057	spawn_flags, user_setup, user_setup_data,
3058	pid_callback, pid_callback_data,
3059	stdin_fd, stdout_fd, stderr_fd, error);
3060
3061	if (session_bus != NULL)
3062	{
3063	/* This asynchronous flush holds a reference until it completes,
3064	* which ensures that the following unref won't immediately kill
3065	* the connection if we were the initial owner.
3066	*/
3067	g_dbus_connection_flush (connection: session_bus, NULL, NULL, NULL);
3068	g_object_unref (object: session_bus);
3069	}
3070
3071	return success;
3072	}
3073
3074	static gboolean
3075	g_desktop_app_info_launch_uris (GAppInfo *appinfo,
3076	GList *uris,
3077	GAppLaunchContext *launch_context,
3078	GError **error)
3079	{
3080	return g_desktop_app_info_launch_uris_internal (appinfo, uris,
3081	launch_context,
3082	_SPAWN_FLAGS_DEFAULT,
3083	NULL, NULL, NULL, NULL,
3084	stdin_fd: -1, stdout_fd: -1, stderr_fd: -1,
3085	error);
3086	}
3087
3088	typedef struct
3089	{
3090	GAppInfo *appinfo;
3091	GList *uris;
3092	GAppLaunchContext *context;
3093	} LaunchUrisData;
3094
3095	static void
3096	launch_uris_data_free (LaunchUrisData *data)
3097	{
3098	g_clear_object (&data->context);
3099	g_list_free_full (list: data->uris, free_func: g_free);
3100	g_free (mem: data);
3101	}
3102
3103	static void
3104	launch_uris_with_dbus_cb (GObject *object,
3105	GAsyncResult *result,
3106	gpointer user_data)
3107	{
3108	GTask *task = G_TASK (user_data);
3109	GError *error = NULL;
3110
3111	g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), res: result, error: &error);
3112	if (error != NULL)
3113	{
3114	g_dbus_error_strip_remote_error (error);
3115	g_task_return_error (task, g_steal_pointer (&error));
3116	}
3117	else
3118	g_task_return_boolean (task, TRUE);
3119
3120	g_object_unref (object: task);
3121	}
3122
3123	static void
3124	launch_uris_flush_cb (GObject *object,
3125	GAsyncResult *result,
3126	gpointer user_data)
3127	{
3128	GTask *task = G_TASK (user_data);
3129
3130	g_dbus_connection_flush_finish (G_DBUS_CONNECTION (object), res: result, NULL);
3131	g_task_return_boolean (task, TRUE);
3132	g_object_unref (object: task);
3133	}
3134
3135	static void
3136	launch_uris_bus_get_cb (GObject *object,
3137	GAsyncResult *result,
3138	gpointer user_data)
3139	{
3140	GTask *task = G_TASK (user_data);
3141	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (g_task_get_source_object (task));
3142	LaunchUrisData *data = g_task_get_task_data (task);
3143	GCancellable *cancellable = g_task_get_cancellable (task);
3144	GDBusConnection *session_bus;
3145	GError *error = NULL;
3146
3147	session_bus = g_bus_get_finish (res: result, NULL);
3148
3149	if (session_bus && info->app_id)
3150	{
3151	/* FIXME: The g_document_portal_add_documents() function, which is called
3152	* from the g_desktop_app_info_launch_uris_with_dbus() function, still
3153	* uses blocking calls.
3154	*/
3155	g_desktop_app_info_launch_uris_with_dbus (info, session_bus,
3156	uris: data->uris, launch_context: data->context,
3157	cancellable,
3158	callback: launch_uris_with_dbus_cb,
3159	g_steal_pointer (&task));
3160	}
3161	else
3162	{
3163	/* FIXME: The D-Bus message from the notify_desktop_launch() function
3164	* can be still lost even if flush is called later. See:
3165	* https://gitlab.freedesktop.org/dbus/dbus/issues/72
3166	*/
3167	g_desktop_app_info_launch_uris_with_spawn (info, session_bus, exec_line: info->exec,
3168	uris: data->uris, launch_context: data->context,
3169	_SPAWN_FLAGS_DEFAULT, NULL,
3170	NULL, NULL, NULL, stdin_fd: -1, stdout_fd: -1, stderr_fd: -1,
3171	error: &error);
3172	if (error != NULL)
3173	{
3174	g_task_return_error (task, g_steal_pointer (&error));
3175	g_object_unref (object: task);
3176	}
3177	else
3178	g_dbus_connection_flush (connection: session_bus,
3179	cancellable,
3180	callback: launch_uris_flush_cb,
3181	g_steal_pointer (&task));
3182	}
3183
3184	g_clear_object (&session_bus);
3185	}
3186
3187	static void
3188	g_desktop_app_info_launch_uris_async (GAppInfo *appinfo,
3189	GList *uris,
3190	GAppLaunchContext *context,
3191	GCancellable *cancellable,
3192	GAsyncReadyCallback callback,
3193	gpointer user_data)
3194	{
3195	GTask *task;
3196	LaunchUrisData *data;
3197
3198	task = g_task_new (source_object: appinfo, cancellable, callback, callback_data: user_data);
3199	g_task_set_source_tag (task, g_desktop_app_info_launch_uris_async);
3200
3201	data = g_new0 (LaunchUrisData, 1);
3202	data->uris = g_list_copy_deep (list: uris, func: (GCopyFunc) g_strdup, NULL);
3203	data->context = (context != NULL) ? g_object_ref (context) : NULL;
3204	g_task_set_task_data (task, g_steal_pointer (&data), task_data_destroy: (GDestroyNotify) launch_uris_data_free);
3205
3206	g_bus_get (bus_type: G_BUS_TYPE_SESSION, cancellable, callback: launch_uris_bus_get_cb, user_data: task);
3207	}
3208
3209	static gboolean
3210	g_desktop_app_info_launch_uris_finish (GAppInfo *appinfo,
3211	GAsyncResult *result,
3212	GError **error)
3213	{
3214	g_return_val_if_fail (g_task_is_valid (result, appinfo), FALSE);
3215
3216	return g_task_propagate_boolean (G_TASK (result), error);
3217	}
3218
3219	static gboolean
3220	g_desktop_app_info_supports_uris (GAppInfo *appinfo)
3221	{
3222	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3223
3224	return info->exec &&
3225	((strstr (haystack: info->exec, needle: "%u") != NULL) ||
3226	(strstr (haystack: info->exec, needle: "%U") != NULL));
3227	}
3228
3229	static gboolean
3230	g_desktop_app_info_supports_files (GAppInfo *appinfo)
3231	{
3232	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3233
3234	return info->exec &&
3235	((strstr (haystack: info->exec, needle: "%f") != NULL) ||
3236	(strstr (haystack: info->exec, needle: "%F") != NULL));
3237	}
3238
3239	static gboolean
3240	g_desktop_app_info_launch (GAppInfo *appinfo,
3241	GList *files,
3242	GAppLaunchContext *launch_context,
3243	GError **error)
3244	{
3245	GList *uris;
3246	char *uri;
3247	gboolean res;
3248
3249	uris = NULL;
3250	while (files)
3251	{
3252	uri = g_file_get_uri (file: files->data);
3253	uris = g_list_prepend (list: uris, data: uri);
3254	files = files->next;
3255	}
3256
3257	uris = g_list_reverse (list: uris);
3258
3259	res = g_desktop_app_info_launch_uris (appinfo, uris, launch_context, error);
3260
3261	g_list_free_full (list: uris, free_func: g_free);
3262
3263	return res;
3264	}
3265
3266	/**
3267	* g_desktop_app_info_launch_uris_as_manager_with_fds:
3268	* @appinfo: a #GDesktopAppInfo
3269	* @uris: (element-type utf8): List of URIs
3270	* @launch_context: (nullable): a #GAppLaunchContext
3271	* @spawn_flags: #GSpawnFlags, used for each process
3272	* @user_setup: (scope async) (nullable): a #GSpawnChildSetupFunc, used once
3273	* for each process.
3274	* @user_setup_data: (closure user_setup) (nullable): User data for @user_setup
3275	* @pid_callback: (scope call) (nullable): Callback for child processes
3276	* @pid_callback_data: (closure pid_callback) (nullable): User data for @callback
3277	* @stdin_fd: file descriptor to use for child's stdin, or -1
3278	* @stdout_fd: file descriptor to use for child's stdout, or -1
3279	* @stderr_fd: file descriptor to use for child's stderr, or -1
3280	* @error: return location for a #GError, or %NULL
3281	*
3282	* Equivalent to g_desktop_app_info_launch_uris_as_manager() but allows
3283	* you to pass in file descriptors for the stdin, stdout and stderr streams
3284	* of the launched process.
3285	*
3286	* If application launching occurs via some non-spawn mechanism (e.g. D-Bus
3287	* activation) then @stdin_fd, @stdout_fd and @stderr_fd are ignored.
3288	*
3289	* Returns: %TRUE on successful launch, %FALSE otherwise.
3290	*
3291	* Since: 2.58
3292	*/
3293	gboolean
3294	g_desktop_app_info_launch_uris_as_manager_with_fds (GDesktopAppInfo *appinfo,
3295	GList *uris,
3296	GAppLaunchContext *launch_context,
3297	GSpawnFlags spawn_flags,
3298	GSpawnChildSetupFunc user_setup,
3299	gpointer user_setup_data,
3300	GDesktopAppLaunchCallback pid_callback,
3301	gpointer pid_callback_data,
3302	gint stdin_fd,
3303	gint stdout_fd,
3304	gint stderr_fd,
3305	GError **error)
3306	{
3307	return g_desktop_app_info_launch_uris_internal (appinfo: (GAppInfo*)appinfo,
3308	uris,
3309	launch_context,
3310	spawn_flags,
3311	user_setup,
3312	user_setup_data,
3313	pid_callback,
3314	pid_callback_data,
3315	stdin_fd,
3316	stdout_fd,
3317	stderr_fd,
3318	error);
3319	}
3320
3321	/**
3322	* g_desktop_app_info_launch_uris_as_manager:
3323	* @appinfo: a #GDesktopAppInfo
3324	* @uris: (element-type utf8): List of URIs
3325	* @launch_context: (nullable): a #GAppLaunchContext
3326	* @spawn_flags: #GSpawnFlags, used for each process
3327	* @user_setup: (scope async) (nullable): a #GSpawnChildSetupFunc, used once
3328	* for each process.
3329	* @user_setup_data: (closure user_setup) (nullable): User data for @user_setup
3330	* @pid_callback: (scope call) (nullable): Callback for child processes
3331	* @pid_callback_data: (closure pid_callback) (nullable): User data for @callback
3332	* @error: return location for a #GError, or %NULL
3333	*
3334	* This function performs the equivalent of g_app_info_launch_uris(),
3335	* but is intended primarily for operating system components that
3336	* launch applications. Ordinary applications should use
3337	* g_app_info_launch_uris().
3338	*
3339	* If the application is launched via GSpawn, then @spawn_flags, @user_setup
3340	* and @user_setup_data are used for the call to g_spawn_async().
3341	* Additionally, @pid_callback (with @pid_callback_data) will be called to
3342	* inform about the PID of the created process. See g_spawn_async_with_pipes()
3343	* for information on certain parameter conditions that can enable an
3344	* optimized posix_spawn() codepath to be used.
3345	*
3346	* If application launching occurs via some other mechanism (eg: D-Bus
3347	* activation) then @spawn_flags, @user_setup, @user_setup_data,
3348	* @pid_callback and @pid_callback_data are ignored.
3349	*
3350	* Returns: %TRUE on successful launch, %FALSE otherwise.
3351	*/
3352	gboolean
3353	g_desktop_app_info_launch_uris_as_manager (GDesktopAppInfo *appinfo,
3354	GList *uris,
3355	GAppLaunchContext *launch_context,
3356	GSpawnFlags spawn_flags,
3357	GSpawnChildSetupFunc user_setup,
3358	gpointer user_setup_data,
3359	GDesktopAppLaunchCallback pid_callback,
3360	gpointer pid_callback_data,
3361	GError **error)
3362	{
3363	return g_desktop_app_info_launch_uris_as_manager_with_fds (appinfo,
3364	uris,
3365	launch_context,
3366	spawn_flags,
3367	user_setup,
3368	user_setup_data,
3369	pid_callback,
3370	pid_callback_data,
3371	stdin_fd: -1, stdout_fd: -1, stderr_fd: -1,
3372	error);
3373	}
3374
3375	/* OnlyShowIn API support {{{2 */
3376
3377	/**
3378	* g_desktop_app_info_set_desktop_env:
3379	* @desktop_env: a string specifying what desktop this is
3380	*
3381	* Sets the name of the desktop that the application is running in.
3382	* This is used by g_app_info_should_show() and
3383	* g_desktop_app_info_get_show_in() to evaluate the
3384	* `OnlyShowIn` and `NotShowIn`
3385	* desktop entry fields.
3386	*
3387	* Should be called only once; subsequent calls are ignored.
3388	*
3389	* Deprecated:2.42:do not use this API. Since 2.42 the value of the
3390	* `XDG_CURRENT_DESKTOP` environment variable will be used.
3391	*/
3392	void
3393	g_desktop_app_info_set_desktop_env (const gchar *desktop_env)
3394	{
3395	get_current_desktops (value: desktop_env);
3396	}
3397
3398	static gboolean
3399	g_desktop_app_info_should_show (GAppInfo *appinfo)
3400	{
3401	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3402
3403	if (info->nodisplay)
3404	return FALSE;
3405
3406	return g_desktop_app_info_get_show_in (info, NULL);
3407	}
3408
3409	/* mime types/default apps support {{{2 */
3410
3411	typedef enum {
3412	CONF_DIR,
3413	APP_DIR,
3414	MIMETYPE_DIR
3415	} DirType;
3416
3417	static char *
3418	ensure_dir (DirType type,
3419	GError **error)
3420	{
3421	char *path, *display_name;
3422	int errsv;
3423
3424	switch (type)
3425	{
3426	case CONF_DIR:
3427	path = g_build_filename (first_element: g_get_user_config_dir (), NULL);
3428	break;
3429
3430	case APP_DIR:
3431	path = g_build_filename (first_element: g_get_user_data_dir (), "applications", NULL);
3432	break;
3433
3434	case MIMETYPE_DIR:
3435	path = g_build_filename (first_element: g_get_user_data_dir (), "mime", "packages", NULL);
3436	break;
3437
3438	default:
3439	g_assert_not_reached ();
3440	}
3441
3442	g_debug ("%s: Ensuring %s", G_STRFUNC, path);
3443
3444	errno = 0;
3445	if (g_mkdir_with_parents (pathname: path, mode: 0700) == 0)
3446	return path;
3447
3448	errsv = errno;
3449	display_name = g_filename_display_name (filename: path);
3450	if (type == APP_DIR)
3451	g_set_error (err: error, G_IO_ERROR, code: g_io_error_from_errno (err_no: errsv),
3452	_("Can’t create user application configuration folder %s: %s"),
3453	display_name, g_strerror (errnum: errsv));
3454	else
3455	g_set_error (err: error, G_IO_ERROR, code: g_io_error_from_errno (err_no: errsv),
3456	_("Can’t create user MIME configuration folder %s: %s"),
3457	display_name, g_strerror (errnum: errsv));
3458
3459	g_free (mem: display_name);
3460	g_free (mem: path);
3461
3462	return NULL;
3463	}
3464
3465	static gboolean
3466	update_mimeapps_list (const char *desktop_id,
3467	const char *content_type,
3468	UpdateMimeFlags flags,
3469	GError **error)
3470	{
3471	char *dirname, *filename, *string;
3472	GKeyFile *key_file;
3473	gboolean load_succeeded, res;
3474	char **old_list, **list;
3475	gsize length, data_size;
3476	char *data;
3477	int i, j, k;
3478	char **content_types;
3479
3480	/* Don't add both at start and end */
3481	g_assert (!((flags & UPDATE_MIME_SET_DEFAULT) &&
3482	(flags & UPDATE_MIME_SET_NON_DEFAULT)));
3483
3484	dirname = ensure_dir (type: CONF_DIR, error);
3485	if (!dirname)
3486	return FALSE;
3487
3488	filename = g_build_filename (first_element: dirname, "mimeapps.list", NULL);
3489	g_free (mem: dirname);
3490
3491	key_file = g_key_file_new ();
3492	load_succeeded = g_key_file_load_from_file (key_file, file: filename, flags: G_KEY_FILE_NONE, NULL);
3493	if (!load_succeeded ||
3494	(!g_key_file_has_group (key_file, ADDED_ASSOCIATIONS_GROUP) &&
3495	!g_key_file_has_group (key_file, REMOVED_ASSOCIATIONS_GROUP) &&
3496	!g_key_file_has_group (key_file, DEFAULT_APPLICATIONS_GROUP)))
3497	{
3498	g_key_file_free (key_file);
3499	key_file = g_key_file_new ();
3500	}
3501
3502	if (content_type)
3503	{
3504	content_types = g_new (char *, 2);
3505	content_types[0] = g_strdup (str: content_type);
3506	content_types[1] = NULL;
3507	}
3508	else
3509	{
3510	content_types = g_key_file_get_keys (key_file, DEFAULT_APPLICATIONS_GROUP, NULL, NULL);
3511	}
3512
3513	for (k = 0; content_types && content_types[k]; k++)
3514	{
3515	/* set as default, if requested so */
3516	string = g_key_file_get_string (key_file,
3517	DEFAULT_APPLICATIONS_GROUP,
3518	key: content_types[k],
3519	NULL);
3520
3521	if (g_strcmp0 (str1: string, str2: desktop_id) != 0 &&
3522	(flags & UPDATE_MIME_SET_DEFAULT))
3523	{
3524	g_free (mem: string);
3525	string = g_strdup (str: desktop_id);
3526
3527	/* add in the non-default list too, if it's not already there */
3528	flags |= UPDATE_MIME_SET_NON_DEFAULT;
3529	}
3530
3531	if (string == NULL || desktop_id == NULL)
3532	g_key_file_remove_key (key_file,
3533	DEFAULT_APPLICATIONS_GROUP,
3534	key: content_types[k],
3535	NULL);
3536	else
3537	g_key_file_set_string (key_file,
3538	DEFAULT_APPLICATIONS_GROUP,
3539	key: content_types[k],
3540	string);
3541
3542	g_free (mem: string);
3543	}
3544
3545	if (content_type)
3546	{
3547	/* reuse the list from above */
3548	}
3549	else
3550	{
3551	g_strfreev (str_array: content_types);
3552	content_types = g_key_file_get_keys (key_file, ADDED_ASSOCIATIONS_GROUP, NULL, NULL);
3553	}
3554
3555	for (k = 0; content_types && content_types[k]; k++)
3556	{
3557	/* Add to the right place in the list */
3558
3559	length = 0;
3560	old_list = g_key_file_get_string_list (key_file, ADDED_ASSOCIATIONS_GROUP,
3561	key: content_types[k], length: &length, NULL);
3562
3563	list = g_new (char *, 1 + length + 1);
3564
3565	i = 0;
3566
3567	/* if we're adding a last-used hint, just put the application in front of the list */
3568	if (flags & UPDATE_MIME_SET_LAST_USED)
3569	{
3570	/* avoid adding this again as non-default later */
3571	if (flags & UPDATE_MIME_SET_NON_DEFAULT)
3572	flags ^= UPDATE_MIME_SET_NON_DEFAULT;
3573
3574	list[i++] = g_strdup (str: desktop_id);
3575	}
3576
3577	if (old_list)
3578	{
3579	for (j = 0; old_list[j] != NULL; j++)
3580	{
3581	if (g_strcmp0 (str1: old_list[j], str2: desktop_id) != 0)
3582	{
3583	/* rewrite other entries if they're different from the new one */
3584	list[i++] = g_strdup (str: old_list[j]);
3585	}
3586	else if (flags & UPDATE_MIME_SET_NON_DEFAULT)
3587	{
3588	/* we encountered an old entry which is equal to the one we're adding as non-default,
3589	* don't change its position in the list.
3590	*/
3591	flags ^= UPDATE_MIME_SET_NON_DEFAULT;
3592	list[i++] = g_strdup (str: old_list[j]);
3593	}
3594	}
3595	}
3596
3597	/* add it at the end of the list */
3598	if (flags & UPDATE_MIME_SET_NON_DEFAULT)
3599	list[i++] = g_strdup (str: desktop_id);
3600
3601	list[i] = NULL;
3602
3603	g_strfreev (str_array: old_list);
3604
3605	if (list[0] == NULL || desktop_id == NULL)
3606	g_key_file_remove_key (key_file,
3607	ADDED_ASSOCIATIONS_GROUP,
3608	key: content_types[k],
3609	NULL);
3610	else
3611	g_key_file_set_string_list (key_file,
3612	ADDED_ASSOCIATIONS_GROUP,
3613	key: content_types[k],
3614	list: (const char * const *)list, length: i);
3615
3616	g_strfreev (str_array: list);
3617	}
3618
3619	if (content_type)
3620	{
3621	/* reuse the list from above */
3622	}
3623	else
3624	{
3625	g_strfreev (str_array: content_types);
3626	content_types = g_key_file_get_keys (key_file, REMOVED_ASSOCIATIONS_GROUP, NULL, NULL);
3627	}
3628
3629	for (k = 0; content_types && content_types[k]; k++)
3630	{
3631	/* Remove from removed associations group (unless remove) */
3632
3633	length = 0;
3634	old_list = g_key_file_get_string_list (key_file, REMOVED_ASSOCIATIONS_GROUP,
3635	key: content_types[k], length: &length, NULL);
3636
3637	list = g_new (char *, 1 + length + 1);
3638
3639	i = 0;
3640	if (flags & UPDATE_MIME_REMOVE)
3641	list[i++] = g_strdup (str: desktop_id);
3642	if (old_list)
3643	{
3644	for (j = 0; old_list[j] != NULL; j++)
3645	{
3646	if (g_strcmp0 (str1: old_list[j], str2: desktop_id) != 0)
3647	list[i++] = g_strdup (str: old_list[j]);
3648	}
3649	}
3650	list[i] = NULL;
3651
3652	g_strfreev (str_array: old_list);
3653
3654	if (list[0] == NULL || desktop_id == NULL)
3655	g_key_file_remove_key (key_file,
3656	REMOVED_ASSOCIATIONS_GROUP,
3657	key: content_types[k],
3658	NULL);
3659	else
3660	g_key_file_set_string_list (key_file,
3661	REMOVED_ASSOCIATIONS_GROUP,
3662	key: content_types[k],
3663	list: (const char * const *)list, length: i);
3664
3665	g_strfreev (str_array: list);
3666	}
3667
3668	g_strfreev (str_array: content_types);
3669
3670	data = g_key_file_to_data (key_file, length: &data_size, error);
3671	g_key_file_free (key_file);
3672
3673	res = g_file_set_contents_full (filename, contents: data, length: data_size,
3674	flags: G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING,
3675	mode: 0600, error);
3676
3677	desktop_file_dirs_invalidate_user_config ();
3678
3679	g_free (mem: filename);
3680	g_free (mem: data);
3681
3682	return res;
3683	}
3684
3685	static gboolean
3686	g_desktop_app_info_set_as_last_used_for_type (GAppInfo *appinfo,
3687	const char *content_type,
3688	GError **error)
3689	{
3690	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3691
3692	if (!g_desktop_app_info_ensure_saved (info, error))
3693	return FALSE;
3694
3695	if (!info->desktop_id)
3696	{
3697	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
3698	_("Application information lacks an identifier"));
3699	return FALSE;
3700	}
3701
3702	/* both add support for the content type and set as last used */
3703	return update_mimeapps_list (desktop_id: info->desktop_id, content_type,
3704	flags: UPDATE_MIME_SET_NON_DEFAULT |
3705	UPDATE_MIME_SET_LAST_USED,
3706	error);
3707	}
3708
3709	static gboolean
3710	g_desktop_app_info_set_as_default_for_type (GAppInfo *appinfo,
3711	const char *content_type,
3712	GError **error)
3713	{
3714	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3715
3716	if (!g_desktop_app_info_ensure_saved (info, error))
3717	return FALSE;
3718
3719	if (!info->desktop_id)
3720	{
3721	g_set_error_literal (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
3722	_("Application information lacks an identifier"));
3723	return FALSE;
3724	}
3725
3726	return update_mimeapps_list (desktop_id: info->desktop_id, content_type,
3727	flags: UPDATE_MIME_SET_DEFAULT,
3728	error);
3729	}
3730
3731	static void
3732	update_program_done (GPid pid,
3733	gint status,
3734	gpointer data)
3735	{
3736	/* Did the application exit correctly */
3737	if (g_spawn_check_exit_status (exit_status: status, NULL))
3738	{
3739	/* Here we could clean out any caches in use */
3740	}
3741	}
3742
3743	static void
3744	run_update_command (char *command,
3745	char *subdir)
3746	{
3747	char *argv[3] = {
3748	NULL,
3749	NULL,
3750	NULL,
3751	};
3752	GPid pid = 0;
3753	GError *error = NULL;
3754
3755	argv[0] = command;
3756	argv[1] = g_build_filename (first_element: g_get_user_data_dir (), subdir, NULL);
3757
3758	if (g_spawn_async (working_directory: "/", argv,
3759	NULL, /* envp */
3760	flags: G_SPAWN_SEARCH_PATH |
3761	G_SPAWN_STDOUT_TO_DEV_NULL |
3762	G_SPAWN_STDERR_TO_DEV_NULL |
3763	G_SPAWN_DO_NOT_REAP_CHILD,
3764	NULL, NULL, /* No setup function */
3765	child_pid: &pid,
3766	error: &error))
3767	g_child_watch_add (pid, function: update_program_done, NULL);
3768	else
3769	{
3770	/* If we get an error at this point, it's quite likely the user doesn't
3771	* have an installed copy of either 'update-mime-database' or
3772	* 'update-desktop-database'. I don't think we want to popup an error
3773	* dialog at this point, so we just do a g_warning to give the user a
3774	* chance of debugging it.
3775	*/
3776	g_warning ("%s", error->message);
3777	g_error_free (error);
3778	}
3779
3780	g_free (mem: argv[1]);
3781	}
3782
3783	static gboolean
3784	g_desktop_app_info_set_as_default_for_extension (GAppInfo *appinfo,
3785	const char *extension,
3786	GError **error)
3787	{
3788	char *filename, *basename, *mimetype;
3789	char *dirname;
3790	gboolean res;
3791
3792	if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (appinfo), error))
3793	return FALSE;
3794
3795	dirname = ensure_dir (type: MIMETYPE_DIR, error);
3796	if (!dirname)
3797	return FALSE;
3798
3799	basename = g_strdup_printf (format: "user-extension-%s.xml", extension);
3800	filename = g_build_filename (first_element: dirname, basename, NULL);
3801	g_free (mem: basename);
3802	g_free (mem: dirname);
3803
3804	mimetype = g_strdup_printf (format: "application/x-extension-%s", extension);
3805
3806	if (!g_file_test (filename, test: G_FILE_TEST_EXISTS))
3807	{
3808	char *contents;
3809
3810	contents =
3811	g_strdup_printf (format: "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
3812	"<mime-info xmlns=\"http://www.freedesktop.org/standards/shared-mime-info\">\n"
3813	" <mime-type type=\"%s\">\n"
3814	" <comment>%s document</comment>\n"
3815	" <glob pattern=\"*.%s\"/>\n"
3816	" </mime-type>\n"
3817	"</mime-info>\n", mimetype, extension, extension);
3818
3819	g_file_set_contents_full (filename, contents, length: -1,
3820	flags: G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING,
3821	mode: 0600, NULL);
3822	g_free (mem: contents);
3823
3824	run_update_command (command: "update-mime-database", subdir: "mime");
3825	}
3826	g_free (mem: filename);
3827
3828	res = g_desktop_app_info_set_as_default_for_type (appinfo,
3829	content_type: mimetype,
3830	error);
3831
3832	g_free (mem: mimetype);
3833
3834	return res;
3835	}
3836
3837	static gboolean
3838	g_desktop_app_info_add_supports_type (GAppInfo *appinfo,
3839	const char *content_type,
3840	GError **error)
3841	{
3842	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3843
3844	if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (info), error))
3845	return FALSE;
3846
3847	return update_mimeapps_list (desktop_id: info->desktop_id, content_type,
3848	flags: UPDATE_MIME_SET_NON_DEFAULT,
3849	error);
3850	}
3851
3852	static gboolean
3853	g_desktop_app_info_can_remove_supports_type (GAppInfo *appinfo)
3854	{
3855	return TRUE;
3856	}
3857
3858	static gboolean
3859	g_desktop_app_info_remove_supports_type (GAppInfo *appinfo,
3860	const char *content_type,
3861	GError **error)
3862	{
3863	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3864
3865	if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (info), error))
3866	return FALSE;
3867
3868	return update_mimeapps_list (desktop_id: info->desktop_id, content_type,
3869	flags: UPDATE_MIME_REMOVE,
3870	error);
3871	}
3872
3873	static const char **
3874	g_desktop_app_info_get_supported_types (GAppInfo *appinfo)
3875	{
3876	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
3877
3878	return (const char**) info->mime_types;
3879	}
3880
3881	/* Saving and deleting {{{2 */
3882
3883	static gboolean
3884	g_desktop_app_info_ensure_saved (GDesktopAppInfo *info,
3885	GError **error)
3886	{
3887	GKeyFile *key_file;
3888	char *dirname;
3889	char *filename;
3890	char *data, *desktop_id;
3891	gsize data_size;
3892	int fd;
3893	gboolean res;
3894
3895	if (info->filename != NULL)
3896	return TRUE;
3897
3898	/* This is only used for object created with
3899	* g_app_info_create_from_commandline. All other
3900	* object should have a filename
3901	*/
3902
3903	dirname = ensure_dir (type: APP_DIR, error);
3904	if (!dirname)
3905	return FALSE;
3906
3907	key_file = g_key_file_new ();
3908
3909	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3910	key: "Encoding", string: "UTF-8");
3911	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3912	G_KEY_FILE_DESKTOP_KEY_VERSION, string: "1.0");
3913	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3914	G_KEY_FILE_DESKTOP_KEY_TYPE,
3915	G_KEY_FILE_DESKTOP_TYPE_APPLICATION);
3916	if (info->terminal)
3917	g_key_file_set_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP,
3918	G_KEY_FILE_DESKTOP_KEY_TERMINAL, TRUE);
3919	if (info->nodisplay)
3920	g_key_file_set_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP,
3921	G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, TRUE);
3922
3923	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3924	G_KEY_FILE_DESKTOP_KEY_EXEC, string: info->exec);
3925
3926	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3927	G_KEY_FILE_DESKTOP_KEY_NAME, string: info->name);
3928
3929	if (info->generic_name != NULL)
3930	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3931	GENERIC_NAME_KEY, string: info->generic_name);
3932
3933	if (info->fullname != NULL)
3934	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3935	FULL_NAME_KEY, string: info->fullname);
3936
3937	g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
3938	G_KEY_FILE_DESKTOP_KEY_COMMENT, string: info->comment);
3939
3940	g_key_file_set_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP,
3941	G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, TRUE);
3942
3943	data = g_key_file_to_data (key_file, length: &data_size, NULL);
3944	g_key_file_free (key_file);
3945
3946	desktop_id = g_strdup_printf (format: "userapp-%s-XXXXXX.desktop", info->name);
3947	filename = g_build_filename (first_element: dirname, desktop_id, NULL);
3948	g_free (mem: desktop_id);
3949	g_free (mem: dirname);
3950
3951	fd = g_mkstemp (tmpl: filename);
3952	if (fd == -1)
3953	{
3954	char *display_name;
3955
3956	display_name = g_filename_display_name (filename);
3957	g_set_error (err: error, G_IO_ERROR, code: G_IO_ERROR_FAILED,
3958	_("Can’t create user desktop file %s"), display_name);
3959	g_free (mem: display_name);
3960	g_free (mem: filename);
3961	g_free (mem: data);
3962	return FALSE;
3963	}
3964
3965	desktop_id = g_path_get_basename (file_name: filename);
3966
3967	/* FIXME - actually handle error */
3968	(void) g_close (fd, NULL);
3969
3970	res = g_file_set_contents_full (filename, contents: data, length: data_size,
3971	flags: G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING,
3972	mode: 0600, error);
3973	g_free (mem: data);
3974	if (!res)
3975	{
3976	g_free (mem: desktop_id);
3977	g_free (mem: filename);
3978	return FALSE;
3979	}
3980
3981	info->filename = filename;
3982	info->desktop_id = desktop_id;
3983
3984	run_update_command (command: "update-desktop-database", subdir: "applications");
3985
3986	/* We just dropped a file in the user's desktop file directory. Save
3987	* the monitor the bother of having to notice it and invalidate
3988	* immediately.
3989	*
3990	* This means that calls directly following this will be able to see
3991	* the results immediately.
3992	*/
3993	desktop_file_dirs_invalidate_user_data ();
3994
3995	return TRUE;
3996	}
3997
3998	static gboolean
3999	g_desktop_app_info_can_delete (GAppInfo *appinfo)
4000	{
4001	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
4002
4003	if (info->filename)
4004	{
4005	if (strstr (haystack: info->filename, needle: "/userapp-"))
4006	return g_access (filename: info->filename, W_OK) == 0;
4007	}
4008
4009	return FALSE;
4010	}
4011
4012	static gboolean
4013	g_desktop_app_info_delete (GAppInfo *appinfo)
4014	{
4015	GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
4016
4017	if (info->filename)
4018	{
4019	if (g_remove (filename: info->filename) == 0)
4020	{
4021	update_mimeapps_list (desktop_id: info->desktop_id, NULL,
4022	flags: UPDATE_MIME_NONE,
4023	NULL);
4024
4025	g_free (mem: info->filename);
4026	info->filename = NULL;
4027	g_free (mem: info->desktop_id);
4028	info->desktop_id = NULL;
4029
4030	return TRUE;
4031	}
4032	}
4033
4034	return FALSE;
4035	}
4036
4037	/* Create for commandline {{{2 */
4038	/**
4039	* g_app_info_create_from_commandline:
4040	* @commandline: (type filename): the commandline to use
4041	* @application_name: (nullable): the application name, or %NULL to use @commandline
4042	* @flags: flags that can specify details of the created #GAppInfo
4043	* @error: a #GError location to store the error occurring, %NULL to ignore.
4044	*
4045	* Creates a new #GAppInfo from the given information.
4046	*
4047	* Note that for @commandline, the quoting rules of the Exec key of the
4048	* [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
4049	* are applied. For example, if the @commandline contains
4050	* percent-encoded URIs, the percent-character must be doubled in order to prevent it from
4051	* being swallowed by Exec key unquoting. See the specification for exact quoting rules.
4052	*
4053	* Returns: (transfer full): new #GAppInfo for given command.
4054	**/
4055	GAppInfo *
4056	g_app_info_create_from_commandline (const char *commandline,
4057	const char *application_name,
4058	GAppInfoCreateFlags flags,
4059	GError **error)
4060	{
4061	char **split;
4062	char *basename;
4063	GDesktopAppInfo *info;
4064
4065	g_return_val_if_fail (commandline, NULL);
4066
4067	info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
4068
4069	info->filename = NULL;
4070	info->desktop_id = NULL;
4071
4072	info->terminal = (flags & G_APP_INFO_CREATE_NEEDS_TERMINAL) != 0;
4073	info->startup_notify = (flags & G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION) != 0;
4074	info->hidden = FALSE;
4075	if ((flags & G_APP_INFO_CREATE_SUPPORTS_URIS) != 0)
4076	info->exec = g_strconcat (string1: commandline, " %u", NULL);
4077	else
4078	info->exec = g_strconcat (string1: commandline, " %f", NULL);
4079	info->nodisplay = TRUE;
4080	info->binary = binary_from_exec (exec: info->exec);
4081
4082	if (application_name)
4083	info->name = g_strdup (str: application_name);
4084	else
4085	{
4086	/* FIXME: this should be more robust. Maybe g_shell_parse_argv and use argv[0] */
4087	split = g_strsplit (string: commandline, delimiter: " ", max_tokens: 2);
4088	basename = split[0] ? g_path_get_basename (file_name: split[0]) : NULL;
4089	g_strfreev (str_array: split);
4090	info->name = basename;
4091	if (info->name == NULL)
4092	info->name = g_strdup (str: "custom");
4093	}
4094	info->comment = g_strdup_printf (_("Custom definition for %s"), info->name);
4095
4096	return G_APP_INFO (info);
4097	}
4098
4099	/* GAppInfo interface init */
4100
4101	static void
4102	g_desktop_app_info_iface_init (GAppInfoIface *iface)
4103	{
4104	iface->dup = g_desktop_app_info_dup;
4105	iface->equal = g_desktop_app_info_equal;
4106	iface->get_id = g_desktop_app_info_get_id;
4107	iface->get_name = g_desktop_app_info_get_name;
4108	iface->get_description = g_desktop_app_info_get_description;
4109	iface->get_executable = g_desktop_app_info_get_executable;
4110	iface->get_icon = g_desktop_app_info_get_icon;
4111	iface->launch = g_desktop_app_info_launch;
4112	iface->supports_uris = g_desktop_app_info_supports_uris;
4113	iface->supports_files = g_desktop_app_info_supports_files;
4114	iface->launch_uris = g_desktop_app_info_launch_uris;
4115	iface->launch_uris_async = g_desktop_app_info_launch_uris_async;
4116	iface->launch_uris_finish = g_desktop_app_info_launch_uris_finish;
4117	iface->should_show = g_desktop_app_info_should_show;
4118	iface->set_as_default_for_type = g_desktop_app_info_set_as_default_for_type;
4119	iface->set_as_default_for_extension = g_desktop_app_info_set_as_default_for_extension;
4120	iface->add_supports_type = g_desktop_app_info_add_supports_type;
4121	iface->can_remove_supports_type = g_desktop_app_info_can_remove_supports_type;
4122	iface->remove_supports_type = g_desktop_app_info_remove_supports_type;
4123	iface->can_delete = g_desktop_app_info_can_delete;
4124	iface->do_delete = g_desktop_app_info_delete;
4125	iface->get_commandline = g_desktop_app_info_get_commandline;
4126	iface->get_display_name = g_desktop_app_info_get_display_name;
4127	iface->set_as_last_used_for_type = g_desktop_app_info_set_as_last_used_for_type;
4128	iface->get_supported_types = g_desktop_app_info_get_supported_types;
4129	}
4130
4131	/* Recommended applications {{{2 */
4132
4133	/* Converts content_type into a list of itself with all of its parent
4134	* types (if include_fallback is enabled) or just returns a single-item
4135	* list with the unaliased content type.
4136	*/
4137	static gchar **
4138	get_list_of_mimetypes (const gchar *content_type,
4139	gboolean include_fallback)
4140	{
4141	gchar *unaliased;
4142	GPtrArray *array;
4143
4144	array = g_ptr_array_new ();
4145	unaliased = _g_unix_content_type_unalias (type: content_type);
4146	g_ptr_array_add (array, data: unaliased);
4147
4148	if (include_fallback)
4149	{
4150	guint i;
4151
4152	/* Iterate the array as we grow it, until we have nothing more to add */
4153	for (i = 0; i < array->len; i++)
4154	{
4155	gchar **parents = _g_unix_content_type_get_parents (g_ptr_array_index (array, i));
4156	gint j;
4157
4158	for (j = 0; parents[j]; j++)
4159	/* Don't add duplicates */
4160	if (!array_contains (array, str: parents[j]))
4161	g_ptr_array_add (array, data: parents[j]);
4162	else
4163	g_free (mem: parents[j]);
4164
4165	/* We already stole or freed each element. Free the container. */
4166	g_free (mem: parents);
4167	}
4168	}
4169
4170	g_ptr_array_add (array, NULL);
4171
4172	return (gchar **) g_ptr_array_free (array, FALSE);
4173	}
4174
4175	static gchar **
4176	g_desktop_app_info_get_desktop_ids_for_content_type (const gchar *content_type,
4177	gboolean include_fallback)
4178	{
4179	GPtrArray *hits, *blocklist;
4180	gchar **types;
4181	guint i, j;
4182
4183	hits = g_ptr_array_new ();
4184	blocklist = g_ptr_array_new ();
4185
4186	types = get_list_of_mimetypes (content_type, include_fallback);
4187
4188	desktop_file_dirs_lock ();
4189
4190	for (i = 0; types[i]; i++)
4191	for (j = 0; j < desktop_file_dirs->len; j++)
4192	desktop_file_dir_mime_lookup (g_ptr_array_index (desktop_file_dirs, j), mime_type: types[i], hits, blocklist);
4193
4194	/* We will keep the hits past unlocking, so we must dup them */
4195	for (i = 0; i < hits->len; i++)
4196	hits->pdata[i] = g_strdup (str: hits->pdata[i]);
4197
4198	desktop_file_dirs_unlock ();
4199
4200	g_ptr_array_add (array: hits, NULL);
4201
4202	g_ptr_array_free (array: blocklist, TRUE);
4203	g_strfreev (str_array: types);
4204
4205	return (gchar **) g_ptr_array_free (array: hits, FALSE);
4206	}
4207
4208	/**
4209	* g_app_info_get_recommended_for_type:
4210	* @content_type: the content type to find a #GAppInfo for
4211	*
4212	* Gets a list of recommended #GAppInfos for a given content type, i.e.
4213	* those applications which claim to support the given content type exactly,
4214	* and not by MIME type subclassing.
4215	* Note that the first application of the list is the last used one, i.e.
4216	* the last one for which g_app_info_set_as_last_used_for_type() has been
4217	* called.
4218	*
4219	* Returns: (element-type GAppInfo) (transfer full): #GList of #GAppInfos
4220	* for given @content_type or %NULL on error.
4221	*
4222	* Since: 2.28
4223	**/
4224	GList *
4225	g_app_info_get_recommended_for_type (const gchar *content_type)
4226	{
4227	gchar **desktop_ids;
4228	GList *infos;
4229	gint i;
4230
4231	g_return_val_if_fail (content_type != NULL, NULL);
4232
4233	desktop_ids = g_desktop_app_info_get_desktop_ids_for_content_type (content_type, FALSE);
4234
4235	infos = NULL;
4236	for (i = 0; desktop_ids[i]; i++)
4237	{
4238	GDesktopAppInfo *info;
4239
4240	info = g_desktop_app_info_new (desktop_id: desktop_ids[i]);
4241	if (info)
4242	infos = g_list_prepend (list: infos, data: info);
4243	}
4244
4245	g_strfreev (str_array: desktop_ids);
4246
4247	return g_list_reverse (list: infos);
4248	}
4249
4250	/**
4251	* g_app_info_get_fallback_for_type:
4252	* @content_type: the content type to find a #GAppInfo for
4253	*
4254	* Gets a list of fallback #GAppInfos for a given content type, i.e.
4255	* those applications which claim to support the given content type
4256	* by MIME type subclassing and not directly.
4257	*
4258	* Returns: (element-type GAppInfo) (transfer full): #GList of #GAppInfos
4259	* for given @content_type or %NULL on error.
4260	*
4261	* Since: 2.28
4262	**/
4263	GList *
4264	g_app_info_get_fallback_for_type (const gchar *content_type)
4265	{
4266	gchar **recommended_ids;
4267	gchar **all_ids;
4268	GList *infos;
4269	gint i;
4270
4271	g_return_val_if_fail (content_type != NULL, NULL);
4272
4273	recommended_ids = g_desktop_app_info_get_desktop_ids_for_content_type (content_type, FALSE);
4274	all_ids = g_desktop_app_info_get_desktop_ids_for_content_type (content_type, TRUE);
4275
4276	infos = NULL;
4277	for (i = 0; all_ids[i]; i++)
4278	{
4279	GDesktopAppInfo *info;
4280	gint j;
4281
4282	/* Don't return the ones on the recommended list */
4283	for (j = 0; recommended_ids[j]; j++)
4284	if (g_str_equal (v1: all_ids[i], v2: recommended_ids[j]))
4285	break;
4286
4287	if (recommended_ids[j])
4288	continue;
4289
4290	info = g_desktop_app_info_new (desktop_id: all_ids[i]);
4291
4292	if (info)
4293	infos = g_list_prepend (list: infos, data: info);
4294	}
4295
4296	g_strfreev (str_array: recommended_ids);
4297	g_strfreev (str_array: all_ids);
4298
4299	return g_list_reverse (list: infos);
4300	}
4301
4302	/**
4303	* g_app_info_get_all_for_type:
4304	* @content_type: the content type to find a #GAppInfo for
4305	*
4306	* Gets a list of all #GAppInfos for a given content type,
4307	* including the recommended and fallback #GAppInfos. See
4308	* g_app_info_get_recommended_for_type() and
4309	* g_app_info_get_fallback_for_type().
4310	*
4311	* Returns: (element-type GAppInfo) (transfer full): #GList of #GAppInfos
4312	* for given @content_type or %NULL on error.
4313	**/
4314	GList *
4315	g_app_info_get_all_for_type (const char *content_type)
4316	{
4317	gchar **desktop_ids;
4318	GList *infos;
4319	gint i;
4320
4321	g_return_val_if_fail (content_type != NULL, NULL);
4322
4323	desktop_ids = g_desktop_app_info_get_desktop_ids_for_content_type (content_type, TRUE);
4324
4325	infos = NULL;
4326	for (i = 0; desktop_ids[i]; i++)
4327	{
4328	GDesktopAppInfo *info;
4329
4330	info = g_desktop_app_info_new (desktop_id: desktop_ids[i]);
4331	if (info)
4332	infos = g_list_prepend (list: infos, data: info);
4333	}
4334
4335	g_strfreev (str_array: desktop_ids);
4336
4337	return g_list_reverse (list: infos);
4338	}
4339
4340	/**
4341	* g_app_info_reset_type_associations:
4342	* @content_type: a content type
4343	*
4344	* Removes all changes to the type associations done by
4345	* g_app_info_set_as_default_for_type(),
4346	* g_app_info_set_as_default_for_extension(),
4347	* g_app_info_add_supports_type() or
4348	* g_app_info_remove_supports_type().
4349	*
4350	* Since: 2.20
4351	*/
4352	void
4353	g_app_info_reset_type_associations (const char *content_type)
4354	{
4355	update_mimeapps_list (NULL, content_type,
4356	flags: UPDATE_MIME_NONE,
4357	NULL);
4358	}
4359
4360	/**
4361	* g_app_info_get_default_for_type:
4362	* @content_type: the content type to find a #GAppInfo for
4363	* @must_support_uris: if %TRUE, the #GAppInfo is expected to
4364	* support URIs
4365	*
4366	* Gets the default #GAppInfo for a given content type.
4367	*
4368	* Returns: (transfer full) (nullable): #GAppInfo for given @content_type or
4369	* %NULL on error.
4370	*/
4371	GAppInfo *
4372	g_app_info_get_default_for_type (const char *content_type,
4373	gboolean must_support_uris)
4374	{
4375	GPtrArray *blocklist;
4376	GPtrArray *results;
4377	GAppInfo *info;
4378	gchar **types;
4379	guint i, j, k;
4380
4381	g_return_val_if_fail (content_type != NULL, NULL);
4382
4383	types = get_list_of_mimetypes (content_type, TRUE);
4384
4385	blocklist = g_ptr_array_new ();
4386	results = g_ptr_array_new ();
4387	info = NULL;
4388
4389	desktop_file_dirs_lock ();
4390
4391	for (i = 0; types[i]; i++)
4392	{
4393	/* Collect all the default apps for this type */
4394	for (j = 0; j < desktop_file_dirs->len; j++)
4395	desktop_file_dir_default_lookup (g_ptr_array_index (desktop_file_dirs, j), mime_type: types[i], results);
4396
4397	/* Consider the associations as well... */
4398	for (j = 0; j < desktop_file_dirs->len; j++)
4399	desktop_file_dir_mime_lookup (g_ptr_array_index (desktop_file_dirs, j), mime_type: types[i], hits: results, blocklist);
4400
4401	/* (If any), see if one of those apps is installed... */
4402	for (j = 0; j < results->len; j++)
4403	{
4404	const gchar *desktop_id = g_ptr_array_index (results, j);
4405
4406	for (k = 0; k < desktop_file_dirs->len; k++)
4407	{
4408	info = (GAppInfo *) desktop_file_dir_get_app (g_ptr_array_index (desktop_file_dirs, k), desktop_id);
4409
4410	if (info)
4411	{
4412	if (!must_support_uris || g_app_info_supports_uris (appinfo: info))
4413	goto out;
4414
4415	g_clear_object (&info);
4416	}
4417	}
4418	}
4419
4420	/* Reset the list, ready to try again with the next (parent)
4421	* mimetype, but keep the blocklist in place.
4422	*/
4423	g_ptr_array_set_size (array: results, length: 0);
4424	}
4425
4426	out:
4427	desktop_file_dirs_unlock ();
4428
4429	g_ptr_array_unref (array: blocklist);
4430	g_ptr_array_unref (array: results);
4431	g_strfreev (str_array: types);
4432
4433	return info;
4434	}
4435
4436	/**
4437	* g_app_info_get_default_for_uri_scheme:
4438	* @uri_scheme: a string containing a URI scheme.
4439	*
4440	* Gets the default application for handling URIs with
4441	* the given URI scheme. A URI scheme is the initial part
4442	* of the URI, up to but not including the ':', e.g. "http",
4443	* "ftp" or "sip".
4444	*
4445	* Returns: (transfer full) (nullable): #GAppInfo for given @uri_scheme or
4446	* %NULL on error.
4447	*/
4448	GAppInfo *
4449	g_app_info_get_default_for_uri_scheme (const char *uri_scheme)
4450	{
4451	GAppInfo *app_info;
4452	char *content_type, *scheme_down;
4453
4454	scheme_down = g_ascii_strdown (str: uri_scheme, len: -1);
4455	content_type = g_strdup_printf (format: "x-scheme-handler/%s", scheme_down);
4456	g_free (mem: scheme_down);
4457	app_info = g_app_info_get_default_for_type (content_type, FALSE);
4458	g_free (mem: content_type);
4459
4460	return app_info;
4461	}
4462
4463	/* "Get all" API {{{2 */
4464
4465	/**
4466	* g_desktop_app_info_get_implementations:
4467	* @interface: the name of the interface
4468	*
4469	* Gets all applications that implement @interface.
4470	*
4471	* An application implements an interface if that interface is listed in
4472	* the Implements= line of the desktop file of the application.
4473	*
4474	* Returns: (element-type GDesktopAppInfo) (transfer full): a list of #GDesktopAppInfo
4475	* objects.
4476	*
4477	* Since: 2.42
4478	**/
4479	GList *
4480	g_desktop_app_info_get_implementations (const gchar *interface)
4481	{
4482	GList *result = NULL;
4483	GList **ptr;
4484	guint i;
4485
4486	desktop_file_dirs_lock ();
4487
4488	for (i = 0; i < desktop_file_dirs->len; i++)
4489	desktop_file_dir_get_implementations (g_ptr_array_index (desktop_file_dirs, i), results: &result, interface);
4490
4491	desktop_file_dirs_unlock ();
4492
4493	ptr = &result;
4494	while (*ptr)
4495	{
4496	gchar *name = (*ptr)->data;
4497	GDesktopAppInfo *app;
4498
4499	app = g_desktop_app_info_new (desktop_id: name);
4500	g_free (mem: name);
4501
4502	if (app)
4503	{
4504	(*ptr)->data = app;
4505	ptr = &(*ptr)->next;
4506	}
4507	else
4508	*ptr = g_list_delete_link (list: *ptr, link_: *ptr);
4509	}
4510
4511	return result;
4512	}
4513
4514	/**
4515	* g_desktop_app_info_search:
4516	* @search_string: the search string to use
4517	*
4518	* Searches desktop files for ones that match @search_string.
4519	*
4520	* The return value is an array of strvs. Each strv contains a list of
4521	* applications that matched @search_string with an equal score. The
4522	* outer list is sorted by score so that the first strv contains the
4523	* best-matching applications, and so on.
4524	* The algorithm for determining matches is undefined and may change at
4525	* any time.
4526	*
4527	* None of the search results are subjected to the normal validation
4528	* checks performed by g_desktop_app_info_new() (for example, checking that
4529	* the executable referenced by a result exists), and so it is possible for
4530	* g_desktop_app_info_new() to return %NULL when passed an app ID returned by
4531	* this function. It is expected that calling code will do this when
4532	* subsequently creating a #GDesktopAppInfo for each result.
4533	*
4534	* Returns: (array zero-terminated=1) (element-type GStrv) (transfer full): a
4535	* list of strvs. Free each item with g_strfreev() and free the outer
4536	* list with g_free().
4537	*/
4538	gchar ***
4539	g_desktop_app_info_search (const gchar *search_string)
4540	{
4541	gchar **search_tokens;
4542	gint last_category = -1;
4543	gchar ***results;
4544	gint n_categories = 0;
4545	gint start_of_category;
4546	gint i, j;
4547	guint k;
4548
4549	search_tokens = g_str_tokenize_and_fold (string: search_string, NULL, NULL);
4550
4551	desktop_file_dirs_lock ();
4552
4553	reset_total_search_results ();
4554
4555	for (k = 0; k < desktop_file_dirs->len; k++)
4556	{
4557	for (j = 0; search_tokens[j]; j++)
4558	{
4559	desktop_file_dir_search (g_ptr_array_index (desktop_file_dirs, k), search_token: search_tokens[j]);
4560	merge_token_results (first: j == 0);
4561	}
4562	merge_directory_results ();
4563	}
4564
4565	sort_total_search_results ();
4566
4567	/* Count the total number of unique categories */
4568	for (i = 0; i < static_total_results_size; i++)
4569	if (static_total_results[i].category != last_category)
4570	{
4571	last_category = static_total_results[i].category;
4572	n_categories++;
4573	}
4574
4575	results = g_new (gchar **, n_categories + 1);
4576
4577	/* Start loading into the results list */
4578	start_of_category = 0;
4579	for (i = 0; i < n_categories; i++)
4580	{
4581	gint n_items_in_category = 0;
4582	gint this_category;
4583	gint j;
4584
4585	this_category = static_total_results[start_of_category].category;
4586
4587	while (start_of_category + n_items_in_category < static_total_results_size &&
4588	static_total_results[start_of_category + n_items_in_category].category == this_category)
4589	n_items_in_category++;
4590
4591	results[i] = g_new (gchar *, n_items_in_category + 1);
4592	for (j = 0; j < n_items_in_category; j++)
4593	results[i][j] = g_strdup (str: static_total_results[start_of_category + j].app_name);
4594	results[i][j] = NULL;
4595
4596	start_of_category += n_items_in_category;
4597	}
4598	results[i] = NULL;
4599
4600	desktop_file_dirs_unlock ();
4601
4602	g_strfreev (str_array: search_tokens);
4603
4604	return results;
4605	}
4606
4607	/**
4608	* g_app_info_get_all:
4609	*
4610	* Gets a list of all of the applications currently registered
4611	* on this system.
4612	*
4613	* For desktop files, this includes applications that have
4614	* `NoDisplay=true` set or are excluded from display by means
4615	* of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
4616	* The returned list does not include applications which have
4617	* the `Hidden` key set.
4618	*
4619	* Returns: (element-type GAppInfo) (transfer full): a newly allocated #GList of references to #GAppInfos.
4620	**/
4621	GList *
4622	g_app_info_get_all (void)
4623	{
4624	GHashTable *apps;
4625	GHashTableIter iter;
4626	gpointer value;
4627	guint i;
4628	GList *infos;
4629
4630	apps = g_hash_table_new_full (hash_func: g_str_hash, key_equal_func: g_str_equal, key_destroy_func: g_free, NULL);
4631
4632	desktop_file_dirs_lock ();
4633
4634	for (i = 0; i < desktop_file_dirs->len; i++)
4635	desktop_file_dir_get_all (g_ptr_array_index (desktop_file_dirs, i), apps);
4636
4637	desktop_file_dirs_unlock ();
4638
4639	infos = NULL;
4640	g_hash_table_iter_init (iter: &iter, hash_table: apps);
4641	while (g_hash_table_iter_next (iter: &iter, NULL, value: &value))
4642	{
4643	if (value)
4644	infos = g_list_prepend (list: infos, data: value);
4645	}
4646
4647	g_hash_table_destroy (hash_table: apps);
4648
4649	return infos;
4650	}
4651
4652	/* GDesktopAppInfoLookup interface {{{2 */
4653
4654	/**
4655	* GDesktopAppInfoLookup:
4656	*
4657	* #GDesktopAppInfoLookup is an opaque data structure and can only be accessed
4658	* using the following functions.
4659	*
4660	* Deprecated: 2.28: The #GDesktopAppInfoLookup interface is deprecated and
4661	* unused by GIO.
4662	**/
4663
4664	G_GNUC_BEGIN_IGNORE_DEPRECATIONS
4665
4666	typedef GDesktopAppInfoLookupIface GDesktopAppInfoLookupInterface;
4667	G_DEFINE_INTERFACE (GDesktopAppInfoLookup, g_desktop_app_info_lookup, G_TYPE_OBJECT)
4668
4669	static void
4670	g_desktop_app_info_lookup_default_init (GDesktopAppInfoLookupInterface *iface)
4671	{
4672	}
4673
4674	/* "Get for mime type" APIs {{{2 */
4675
4676	/**
4677	* g_desktop_app_info_lookup_get_default_for_uri_scheme:
4678	* @lookup: a #GDesktopAppInfoLookup
4679	* @uri_scheme: a string containing a URI scheme.
4680	*
4681	* Gets the default application for launching applications
4682	* using this URI scheme for a particular #GDesktopAppInfoLookup
4683	* implementation.
4684	*
4685	* The #GDesktopAppInfoLookup interface and this function is used
4686	* to implement g_app_info_get_default_for_uri_scheme() backends
4687	* in a GIO module. There is no reason for applications to use it
4688	* directly. Applications should use g_app_info_get_default_for_uri_scheme().
4689	*
4690	* Returns: (transfer full) (nullable): #GAppInfo for given @uri_scheme or
4691	* %NULL on error.
4692	*
4693	* Deprecated: 2.28: The #GDesktopAppInfoLookup interface is deprecated and
4694	* unused by GIO.
4695	*/
4696	GAppInfo *
4697	g_desktop_app_info_lookup_get_default_for_uri_scheme (GDesktopAppInfoLookup *lookup,
4698	const char *uri_scheme)
4699	{
4700	GDesktopAppInfoLookupIface *iface;
4701
4702	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO_LOOKUP (lookup), NULL);
4703
4704	iface = G_DESKTOP_APP_INFO_LOOKUP_GET_IFACE (lookup);
4705
4706	return (* iface->get_default_for_uri_scheme) (lookup, uri_scheme);
4707	}
4708
4709	G_GNUC_END_IGNORE_DEPRECATIONS
4710
4711	/* Misc getter APIs {{{2 */
4712
4713	/**
4714	* g_desktop_app_info_get_startup_wm_class:
4715	* @info: a #GDesktopAppInfo that supports startup notify
4716	*
4717	* Retrieves the StartupWMClass field from @info. This represents the
4718	* WM_CLASS property of the main window of the application, if launched
4719	* through @info.
4720	*
4721	* Returns: (nullable) (transfer none): the startup WM class, or %NULL if none is set
4722	* in the desktop file.
4723	*
4724	* Since: 2.34
4725	*/
4726	const char *
4727	g_desktop_app_info_get_startup_wm_class (GDesktopAppInfo *info)
4728	{
4729	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4730
4731	return info->startup_wm_class;
4732	}
4733
4734	/**
4735	* g_desktop_app_info_get_string:
4736	* @info: a #GDesktopAppInfo
4737	* @key: the key to look up
4738	*
4739	* Looks up a string value in the keyfile backing @info.
4740	*
4741	* The @key is looked up in the "Desktop Entry" group.
4742	*
4743	* Returns: (nullable): a newly allocated string, or %NULL if the key
4744	* is not found
4745	*
4746	* Since: 2.36
4747	*/
4748	char *
4749	g_desktop_app_info_get_string (GDesktopAppInfo *info,
4750	const char *key)
4751	{
4752	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4753
4754	return g_key_file_get_string (key_file: info->keyfile,
4755	G_KEY_FILE_DESKTOP_GROUP, key, NULL);
4756	}
4757
4758	/**
4759	* g_desktop_app_info_get_locale_string:
4760	* @info: a #GDesktopAppInfo
4761	* @key: the key to look up
4762	*
4763	* Looks up a localized string value in the keyfile backing @info
4764	* translated to the current locale.
4765	*
4766	* The @key is looked up in the "Desktop Entry" group.
4767	*
4768	* Returns: (nullable): a newly allocated string, or %NULL if the key
4769	* is not found
4770	*
4771	* Since: 2.56
4772	*/
4773	char *
4774	g_desktop_app_info_get_locale_string (GDesktopAppInfo *info,
4775	const char *key)
4776	{
4777	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4778	g_return_val_if_fail (key != NULL && *key != '\0', NULL);
4779
4780	return g_key_file_get_locale_string (key_file: info->keyfile,
4781	G_KEY_FILE_DESKTOP_GROUP,
4782	key, NULL, NULL);
4783	}
4784
4785	/**
4786	* g_desktop_app_info_get_boolean:
4787	* @info: a #GDesktopAppInfo
4788	* @key: the key to look up
4789	*
4790	* Looks up a boolean value in the keyfile backing @info.
4791	*
4792	* The @key is looked up in the "Desktop Entry" group.
4793	*
4794	* Returns: the boolean value, or %FALSE if the key
4795	* is not found
4796	*
4797	* Since: 2.36
4798	*/
4799	gboolean
4800	g_desktop_app_info_get_boolean (GDesktopAppInfo *info,
4801	const char *key)
4802	{
4803	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), FALSE);
4804
4805	return g_key_file_get_boolean (key_file: info->keyfile,
4806	G_KEY_FILE_DESKTOP_GROUP, key, NULL);
4807	}
4808
4809	/**
4810	* g_desktop_app_info_get_string_list:
4811	* @info: a #GDesktopAppInfo
4812	* @key: the key to look up
4813	* @length: (out) (optional): return location for the number of returned strings, or %NULL
4814	*
4815	* Looks up a string list value in the keyfile backing @info.
4816	*
4817	* The @key is looked up in the "Desktop Entry" group.
4818	*
4819	* Returns: (array zero-terminated=1 length=length) (element-type utf8) (transfer full):
4820	* a %NULL-terminated string array or %NULL if the specified
4821	* key cannot be found. The array should be freed with g_strfreev().
4822	*
4823	* Since: 2.60
4824	*/
4825	gchar **
4826	g_desktop_app_info_get_string_list (GDesktopAppInfo *info,
4827	const char *key,
4828	gsize *length)
4829	{
4830	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4831
4832	return g_key_file_get_string_list (key_file: info->keyfile,
4833	G_KEY_FILE_DESKTOP_GROUP, key, length, NULL);
4834	}
4835
4836	/**
4837	* g_desktop_app_info_has_key:
4838	* @info: a #GDesktopAppInfo
4839	* @key: the key to look up
4840	*
4841	* Returns whether @key exists in the "Desktop Entry" group
4842	* of the keyfile backing @info.
4843	*
4844	* Returns: %TRUE if the @key exists
4845	*
4846	* Since: 2.36
4847	*/
4848	gboolean
4849	g_desktop_app_info_has_key (GDesktopAppInfo *info,
4850	const char *key)
4851	{
4852	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), FALSE);
4853
4854	return g_key_file_has_key (key_file: info->keyfile,
4855	G_KEY_FILE_DESKTOP_GROUP, key, NULL);
4856	}
4857
4858	/* Desktop actions support {{{2 */
4859
4860	/**
4861	* g_desktop_app_info_list_actions:
4862	* @info: a #GDesktopAppInfo
4863	*
4864	* Returns the list of "additional application actions" supported on the
4865	* desktop file, as per the desktop file specification.
4866	*
4867	* As per the specification, this is the list of actions that are
4868	* explicitly listed in the "Actions" key of the [Desktop Entry] group.
4869	*
4870	* Returns: (array zero-terminated=1) (element-type utf8) (transfer none): a list of strings, always non-%NULL
4871	*
4872	* Since: 2.38
4873	**/
4874	const gchar * const *
4875	g_desktop_app_info_list_actions (GDesktopAppInfo *info)
4876	{
4877	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4878
4879	return (const gchar **) info->actions;
4880	}
4881
4882	static gboolean
4883	app_info_has_action (GDesktopAppInfo *info,
4884	const gchar *action_name)
4885	{
4886	gint i;
4887
4888	for (i = 0; info->actions[i]; i++)
4889	if (g_str_equal (v1: info->actions[i], v2: action_name))
4890	return TRUE;
4891
4892	return FALSE;
4893	}
4894
4895	/**
4896	* g_desktop_app_info_get_action_name:
4897	* @info: a #GDesktopAppInfo
4898	* @action_name: the name of the action as from
4899	* g_desktop_app_info_list_actions()
4900	*
4901	* Gets the user-visible display name of the "additional application
4902	* action" specified by @action_name.
4903	*
4904	* This corresponds to the "Name" key within the keyfile group for the
4905	* action.
4906	*
4907	* Returns: (transfer full): the locale-specific action name
4908	*
4909	* Since: 2.38
4910	*/
4911	gchar *
4912	g_desktop_app_info_get_action_name (GDesktopAppInfo *info,
4913	const gchar *action_name)
4914	{
4915	gchar *group_name;
4916	gchar *result;
4917
4918	g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (info), NULL);
4919	g_return_val_if_fail (action_name != NULL, NULL);
4920	g_return_val_if_fail (app_info_has_action (info, action_name), NULL);
4921
4922	group_name = g_strdup_printf (format: "Desktop Action %s", action_name);
4923	result = g_key_file_get_locale_string (key_file: info->keyfile, group_name, key: "Name", NULL, NULL);
4924	g_free (mem: group_name);
4925
4926	/* The spec says that the Name field must be given.
4927	*
4928	* If it's not, let's follow the behaviour of our get_name()
4929	* implementation above and never return %NULL.
4930	*/
4931	if (result == NULL)
4932	result = g_strdup (_("Unnamed"));
4933
4934	return result;
4935	}
4936
4937	/**
4938	* g_desktop_app_info_launch_action:
4939	* @info: a #GDesktopAppInfo
4940	* @action_name: the name of the action as from
4941	* g_desktop_app_info_list_actions()
4942	* @launch_context: (nullable): a #GAppLaunchContext
4943	*
4944	* Activates the named application action.
4945	*
4946	* You may only call this function on action names that were
4947	* returned from g_desktop_app_info_list_actions().
4948	*
4949	* Note that if the main entry of the desktop file indicates that the
4950	* application supports startup notification, and @launch_context is
4951	* non-%NULL, then startup notification will be used when activating the
4952	* action (and as such, invocation of the action on the receiving side
4953	* must signal the end of startup notification when it is completed).
4954	* This is the expected behaviour of applications declaring additional
4955	* actions, as per the desktop file specification.
4956	*
4957	* As with g_app_info_launch() there is no way to detect failures that
4958	* occur while using this function.
4959	*
4960	* Since: 2.38
4961	*/
4962	void
4963	g_desktop_app_info_launch_action (GDesktopAppInfo *info,
4964	const gchar *action_name,
4965	GAppLaunchContext *launch_context)
4966	{
4967	GDBusConnection *session_bus;
4968
4969	g_return_if_fail (G_IS_DESKTOP_APP_INFO (info));
4970	g_return_if_fail (action_name != NULL);
4971	g_return_if_fail (app_info_has_action (info, action_name));
4972
4973	session_bus = g_bus_get_sync (bus_type: G_BUS_TYPE_SESSION, NULL, NULL);
4974
4975	if (session_bus && info->app_id)
4976	{
4977	gchar *object_path;
4978
4979	object_path = object_path_from_appid (appid: info->app_id);
4980	g_dbus_connection_call (connection: session_bus, bus_name: info->app_id, object_path,
4981	interface_name: "org.freedesktop.Application", method_name: "ActivateAction",
4982	parameters: g_variant_new (format_string: "(sav@a{sv})", action_name, NULL,
4983	g_desktop_app_info_make_platform_data (info, NULL, launch_context)),
4984	NULL, flags: G_DBUS_CALL_FLAGS_NONE, timeout_msec: -1, NULL, NULL, NULL);
4985	g_free (mem: object_path);
4986	}
4987	else
4988	{
4989	gchar *group_name;
4990	gchar *exec_line;
4991
4992	group_name = g_strdup_printf (format: "Desktop Action %s", action_name);
4993	exec_line = g_key_file_get_string (key_file: info->keyfile, group_name, key: "Exec", NULL);
4994	g_free (mem: group_name);
4995
4996	if (exec_line)
4997	g_desktop_app_info_launch_uris_with_spawn (info, session_bus, exec_line, NULL, launch_context,
4998	_SPAWN_FLAGS_DEFAULT, NULL, NULL, NULL, NULL,
4999	stdin_fd: -1, stdout_fd: -1, stderr_fd: -1, NULL);
5000
5001	g_free (mem: exec_line);
5002	}
5003
5004	if (session_bus != NULL)
5005	{
5006	g_dbus_connection_flush (connection: session_bus, NULL, NULL, NULL);
5007	g_object_unref (object: session_bus);
5008	}
5009	}
5010	/* Epilogue {{{1 */
5011
5012	/* vim:set foldmethod=marker: */
5013