543504 – crash in Epiphany Web Browser: Opening local file
[platform/upstream/glib.git] / gio / gdesktopappinfo.c
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 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, write to the
18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19  * Boston, MA 02111-1307, USA.
20  *
21  * Author: Alexander Larsson <alexl@redhat.com>
22  */
23
24 #include "config.h"
25
26 #include <errno.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/wait.h>
30
31 #ifdef HAVE_CRT_EXTERNS_H
32 #include <crt_externs.h>
33 #endif
34
35 #include "gcontenttypeprivate.h"
36 #include "gdesktopappinfo.h"
37 #include "gfile.h"
38 #include "gioerror.h"
39 #include "gthemedicon.h"
40 #include "gfileicon.h"
41 #include <glib/gstdio.h>
42 #include "glibintl.h"
43 #include "giomodule-priv.h"
44 #include "gappinfo.h"
45
46 #include "gioalias.h"
47
48 /**
49  * SECTION:gdesktopappinfo
50  * @short_description: Application information from desktop files
51  * @include: gio/gdesktopappinfo.h 
52  * 
53  * #GDesktopAppInfo is an implementation of #GAppInfo based on
54  * desktop files.
55  *
56  **/
57
58 #define DEFAULT_APPLICATIONS_GROUP  "Default Applications" 
59 #define ADDED_ASSOCIATIONS_GROUP    "Added Associations" 
60 #define REMOVED_ASSOCIATIONS_GROUP  "Removed Associations" 
61 #define MIME_CACHE_GROUP            "MIME Cache"
62
63 static void     g_desktop_app_info_iface_init         (GAppInfoIface    *iface);
64 static GList *  get_all_desktop_entries_for_mime_type (const char       *base_mime_type);
65 static void     mime_info_cache_reload                (const char       *dir);
66 static gboolean g_desktop_app_info_ensure_saved       (GDesktopAppInfo  *info,
67                                                        GError          **error);
68
69 /**
70  * GDesktopAppInfo:
71  * 
72  * Information about an installed application from a desktop file.
73  */
74 struct _GDesktopAppInfo
75 {
76   GObject parent_instance;
77
78   char *desktop_id;
79   char *filename;
80
81   char *name;
82   /* FIXME: what about GenericName ? */
83   char *comment;
84   char *icon_name;
85   GIcon *icon;
86   char **only_show_in;
87   char **not_show_in;
88   char *try_exec;
89   char *exec;
90   char *binary;
91   char *path;
92
93   guint nodisplay       : 1;
94   guint hidden          : 1;
95   guint terminal        : 1;
96   guint startup_notify  : 1;
97   /* FIXME: what about StartupWMClass ? */
98 };
99
100 G_DEFINE_TYPE_WITH_CODE (GDesktopAppInfo, g_desktop_app_info, G_TYPE_OBJECT,
101                          G_IMPLEMENT_INTERFACE (G_TYPE_APP_INFO,
102                                                 g_desktop_app_info_iface_init))
103
104 static gpointer
105 search_path_init (gpointer data)
106 {
107   char **args = NULL;
108   const char * const *data_dirs;
109   const char *user_data_dir;
110   int i, length, j;
111
112   data_dirs = g_get_system_data_dirs ();
113   length = g_strv_length ((char **) data_dirs);
114   
115   args = g_new (char *, length + 2);
116   
117   j = 0;
118   user_data_dir = g_get_user_data_dir ();
119   args[j++] = g_build_filename (user_data_dir, "applications", NULL);
120   for (i = 0; i < length; i++)
121     args[j++] = g_build_filename (data_dirs[i],
122                                   "applications", NULL);
123   args[j++] = NULL;
124   
125   return args;
126 }
127   
128 static const char * const *
129 get_applications_search_path (void)
130 {
131   static GOnce once_init = G_ONCE_INIT;
132   return g_once (&once_init, search_path_init, NULL);
133 }
134
135 static void
136 g_desktop_app_info_finalize (GObject *object)
137 {
138   GDesktopAppInfo *info;
139
140   info = G_DESKTOP_APP_INFO (object);
141
142   g_free (info->desktop_id);
143   g_free (info->filename);
144   g_free (info->name);
145   g_free (info->comment);
146   g_free (info->icon_name);
147   if (info->icon)
148     g_object_unref (info->icon);
149   g_strfreev (info->only_show_in);
150   g_strfreev (info->not_show_in);
151   g_free (info->try_exec);
152   g_free (info->exec);
153   g_free (info->binary);
154   g_free (info->path);
155   
156   G_OBJECT_CLASS (g_desktop_app_info_parent_class)->finalize (object);
157 }
158
159 static void
160 g_desktop_app_info_class_init (GDesktopAppInfoClass *klass)
161 {
162   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
163   
164   gobject_class->finalize = g_desktop_app_info_finalize;
165 }
166
167 static void
168 g_desktop_app_info_init (GDesktopAppInfo *local)
169 {
170 }
171
172 static char *
173 binary_from_exec (const char *exec)
174 {
175   const char *p, *start;
176   
177   p = exec;
178   while (*p == ' ')
179     p++;
180   start = p;
181   while (*p != ' ' && *p != 0)
182     p++;
183   
184   return g_strndup (start, p - start);
185   
186 }
187
188 /**
189  * g_desktop_app_info_new_from_keyfile:
190  * @key_file: an opened #GKeyFile
191  * 
192  * Creates a new #GDesktopAppInfo.
193  *
194  * Returns: a new #GDesktopAppInfo or %NULL on error.
195  *
196  * Since: 2.18
197  **/
198 GDesktopAppInfo *
199 g_desktop_app_info_new_from_keyfile (GKeyFile *key_file)
200 {
201   GDesktopAppInfo *info;
202   char *start_group;
203   char *type;
204   char *try_exec;
205   
206   start_group = g_key_file_get_start_group (key_file);
207   if (start_group == NULL || strcmp (start_group, G_KEY_FILE_DESKTOP_GROUP) != 0)
208     {
209       g_free (start_group);
210       return NULL;
211     }
212   g_free (start_group);
213
214   type = g_key_file_get_string (key_file,
215                                 G_KEY_FILE_DESKTOP_GROUP,
216                                 G_KEY_FILE_DESKTOP_KEY_TYPE,
217                                 NULL);
218   if (type == NULL || strcmp (type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) != 0)
219     {
220       g_free (type);
221       return NULL;
222     }
223   g_free (type);
224
225   try_exec = g_key_file_get_string (key_file,
226                                     G_KEY_FILE_DESKTOP_GROUP,
227                                     G_KEY_FILE_DESKTOP_KEY_TRY_EXEC,
228                                     NULL);
229   if (try_exec && try_exec[0] != '\0')
230     {
231       char *t;
232       t = g_find_program_in_path (try_exec);
233       if (t == NULL)
234         {
235           g_free (try_exec);
236           return NULL;
237         }
238       g_free (t);
239     }
240
241   info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
242   info->filename = NULL;
243
244   info->name = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NAME, NULL, NULL);
245   info->comment = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_COMMENT, NULL, NULL);
246   info->nodisplay = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, NULL) != FALSE;
247   info->icon_name =  g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_ICON, NULL, NULL);
248   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);
249   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);
250   info->try_exec = try_exec;
251   info->exec = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_EXEC, NULL);
252   info->path = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_PATH, NULL);
253   info->terminal = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_TERMINAL, NULL) != FALSE;
254   info->startup_notify = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY, NULL) != FALSE;
255   info->hidden = g_key_file_get_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_HIDDEN, NULL) != FALSE;
256   
257   info->icon = NULL;
258   if (info->icon_name)
259     {
260       if (g_path_is_absolute (info->icon_name))
261         {
262           GFile *file;
263           
264           file = g_file_new_for_path (info->icon_name);
265           info->icon = g_file_icon_new (file);
266           g_object_unref (file);
267         }
268       else
269         info->icon = g_themed_icon_new (info->icon_name);
270     }
271   
272   if (info->exec)
273     info->binary = binary_from_exec (info->exec);
274   
275   return info;
276 }
277
278 /**
279  * g_desktop_app_info_new_from_filename:
280  * @filename: a string containing a file name.
281  * 
282  * Creates a new #GDesktopAppInfo.
283  *
284  * Returns: a new #GDesktopAppInfo or %NULL on error.
285  **/
286 GDesktopAppInfo *
287 g_desktop_app_info_new_from_filename (const char *filename)
288 {
289   GKeyFile *key_file;
290   GDesktopAppInfo *info = NULL;
291
292   key_file = g_key_file_new ();
293   
294   if (g_key_file_load_from_file (key_file,
295                                  filename,
296                                  G_KEY_FILE_NONE,
297                                  NULL))
298     {
299       info = g_desktop_app_info_new_from_keyfile (key_file);
300       if (info)
301         info->filename = g_strdup (filename);
302     }  
303
304   g_key_file_free (key_file);
305
306   return info;
307 }
308
309 /**
310  * g_desktop_app_info_new:
311  * @desktop_id: the desktop file id
312  * 
313  * Creates a new #GDesktopAppInfo.
314  * 
315  * Returns: a new #GDesktopAppInfo, or %NULL if no desktop file with that id
316  **/
317 GDesktopAppInfo *
318 g_desktop_app_info_new (const char *desktop_id)
319 {
320   GDesktopAppInfo *appinfo;
321   const char * const *dirs;
322   char *basename;
323   int i;
324
325   dirs = get_applications_search_path ();
326
327   basename = g_strdup (desktop_id);
328   
329   for (i = 0; dirs[i] != NULL; i++)
330     {
331       char *filename;
332       char *p;
333
334       filename = g_build_filename (dirs[i], desktop_id, NULL);
335       appinfo = g_desktop_app_info_new_from_filename (filename);
336       g_free (filename);
337       if (appinfo != NULL)
338         goto found;
339
340       p = basename;
341       while ((p = strchr (p, '-')) != NULL)
342         {
343           *p = '/';
344           
345           filename = g_build_filename (dirs[i], basename, NULL);
346           appinfo = g_desktop_app_info_new_from_filename (filename);
347           g_free (filename);
348           if (appinfo != NULL)
349             goto found;
350           *p = '-';
351           p++;
352         }
353     }
354   
355   g_free (basename);
356   return NULL;
357
358  found:
359   g_free (basename);
360   
361   appinfo->desktop_id = g_strdup (desktop_id);
362
363   if (g_desktop_app_info_get_is_hidden (appinfo))
364     {
365       g_object_unref (appinfo);
366       appinfo = NULL;
367     }
368   
369   return appinfo;
370 }
371
372 static GAppInfo *
373 g_desktop_app_info_dup (GAppInfo *appinfo)
374 {
375   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
376   GDesktopAppInfo *new_info;
377   
378   new_info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
379
380   new_info->filename = g_strdup (info->filename);
381   new_info->desktop_id = g_strdup (info->desktop_id);
382   
383   new_info->name = g_strdup (info->name);
384   new_info->comment = g_strdup (info->comment);
385   new_info->nodisplay = info->nodisplay;
386   new_info->icon_name = g_strdup (info->icon_name);
387   new_info->icon = g_object_ref (info->icon);
388   new_info->only_show_in = g_strdupv (info->only_show_in);
389   new_info->not_show_in = g_strdupv (info->not_show_in);
390   new_info->try_exec = g_strdup (info->try_exec);
391   new_info->exec = g_strdup (info->exec);
392   new_info->binary = g_strdup (info->binary);
393   new_info->path = g_strdup (info->path);
394   new_info->hidden = info->hidden;
395   new_info->terminal = info->terminal;
396   new_info->startup_notify = info->startup_notify;
397   
398   return G_APP_INFO (new_info);
399 }
400
401 static gboolean
402 g_desktop_app_info_equal (GAppInfo *appinfo1,
403                           GAppInfo *appinfo2)
404 {
405   GDesktopAppInfo *info1 = G_DESKTOP_APP_INFO (appinfo1);
406   GDesktopAppInfo *info2 = G_DESKTOP_APP_INFO (appinfo2);
407
408   if (info1->desktop_id == NULL ||
409       info2->desktop_id == NULL)
410     return info1 == info2;
411
412   return strcmp (info1->desktop_id, info2->desktop_id) == 0;
413 }
414
415 static const char *
416 g_desktop_app_info_get_id (GAppInfo *appinfo)
417 {
418   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
419
420   return info->desktop_id;
421 }
422
423 static const char *
424 g_desktop_app_info_get_name (GAppInfo *appinfo)
425 {
426   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
427
428   if (info->name == NULL)
429     return _("Unnamed");
430   return info->name;
431 }
432
433 /**
434  * g_desktop_app_info_get_is_hidden:
435  * @info: a #GDesktopAppInfo.
436  *
437  * A desktop file is hidden if the Hidden key in it is
438  * set to True.
439  *
440  * Returns: %TRUE if hidden, %FALSE otherwise. 
441  **/
442 gboolean
443 g_desktop_app_info_get_is_hidden (GDesktopAppInfo *info)
444 {
445   return info->hidden;
446 }
447
448 static const char *
449 g_desktop_app_info_get_description (GAppInfo *appinfo)
450 {
451   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
452   
453   return info->comment;
454 }
455
456 static const char *
457 g_desktop_app_info_get_executable (GAppInfo *appinfo)
458 {
459   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
460   
461   return info->binary;
462 }
463
464 static GIcon *
465 g_desktop_app_info_get_icon (GAppInfo *appinfo)
466 {
467   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
468
469   return info->icon;
470 }
471
472 static char *
473 expand_macro_single (char macro, char *uri)
474 {
475   GFile *file;
476   char *result = NULL;
477   char *path;
478
479   file = g_file_new_for_uri (uri);
480   path = g_file_get_path (file);
481   g_object_unref (file);
482   
483   switch (macro)
484     {
485     case 'u':
486     case 'U':   
487       result = g_shell_quote (uri);
488       break;
489     case 'f':
490     case 'F':
491       if (path)
492         result = g_shell_quote (path);
493       break;
494     case 'd':
495     case 'D':
496       if (path)
497         result = g_shell_quote (g_path_get_dirname (path));
498       break;
499     case 'n':
500     case 'N':
501       if (path)
502         result = g_shell_quote (g_path_get_basename (path));
503       break;
504     }
505
506   g_free (path);
507   
508   return result;
509 }
510
511 static void
512 expand_macro (char              macro, 
513               GString          *exec, 
514               GDesktopAppInfo  *info, 
515               GList           **uri_list)
516 {
517   GList *uris = *uri_list;
518   char *expanded;
519   
520   g_return_if_fail (exec != NULL);
521   
522   switch (macro)
523     {
524     case 'u':
525     case 'f':
526     case 'd':
527     case 'n':
528       if (uris)
529         {
530           expanded = expand_macro_single (macro, uris->data);
531           if (expanded)
532             {
533               g_string_append (exec, expanded);
534               g_free (expanded);
535             }
536           uris = uris->next;
537         }
538
539       break;
540
541     case 'U':   
542     case 'F':
543     case 'D':
544     case 'N':
545       while (uris)
546         {
547           expanded = expand_macro_single (macro, uris->data);
548           if (expanded)
549             {
550               g_string_append (exec, expanded);
551               g_free (expanded);
552             }
553           
554           uris = uris->next;
555           
556           if (uris != NULL && expanded)
557             g_string_append_c (exec, ' ');
558         }
559
560       break;
561
562     case 'i':
563       if (info->icon_name)
564         {
565           g_string_append (exec, "--icon ");
566           g_string_append (exec, info->icon_name);
567         }
568       break;
569
570     case 'c':
571       if (info->name) 
572         g_string_append (exec, info->name);
573       break;
574
575     case 'k':
576       if (info->filename) 
577         g_string_append (exec, info->filename);
578       break;
579
580     case 'm': /* deprecated */
581       break;
582
583     case '%':
584       g_string_append_c (exec, '%');
585       break;
586     }
587   
588   *uri_list = uris;
589 }
590
591 static gboolean
592 expand_application_parameters (GDesktopAppInfo   *info,
593                                GList            **uris,
594                                int               *argc,
595                                char            ***argv,
596                                GError           **error)
597 {
598   GList *uri_list = *uris;
599   const char *p = info->exec;
600   GString *expanded_exec = g_string_new (NULL);
601   gboolean res;
602   
603   if (info->exec == NULL)
604     {
605       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
606                            _("Desktop file didn't specify Exec field"));
607       return FALSE;
608     }
609   
610   while (*p)
611     {
612       if (p[0] == '%' && p[1] != '\0')
613         {
614           expand_macro (p[1], expanded_exec, info, uris);
615           p++;
616         }
617       else
618         g_string_append_c (expanded_exec, *p);
619       
620       p++;
621     }
622   
623   /* No file substitutions */
624   if (uri_list == *uris && uri_list != NULL)
625     {
626       /* If there is no macro default to %f. This is also what KDE does */
627       g_string_append_c (expanded_exec, ' ');
628       expand_macro ('f', expanded_exec, info, uris);
629     }
630   
631   res = g_shell_parse_argv (expanded_exec->str, argc, argv, error);
632   g_string_free (expanded_exec, TRUE);
633   return res;
634 }
635
636 static gboolean
637 prepend_terminal_to_vector (int    *argc,
638                             char ***argv)
639 {
640 #ifndef G_OS_WIN32
641   char **real_argv;
642   int real_argc;
643   int i, j;
644   char **term_argv = NULL;
645   int term_argc = 0;
646   char *check;
647   char **the_argv;
648   
649   g_return_val_if_fail (argc != NULL, FALSE);
650   g_return_val_if_fail (argv != NULL, FALSE);
651         
652   /* sanity */
653   if(*argv == NULL)
654     *argc = 0;
655   
656   the_argv = *argv;
657
658   /* compute size if not given */
659   if (*argc < 0)
660     {
661       for (i = 0; the_argv[i] != NULL; i++)
662         ;
663       *argc = i;
664     }
665   
666   term_argc = 2;
667   term_argv = g_new0 (char *, 3);
668
669   check = g_find_program_in_path ("gnome-terminal");
670   if (check != NULL)
671     {
672       term_argv[0] = check;
673       /* Note that gnome-terminal takes -x and
674        * as -e in gnome-terminal is broken we use that. */
675       term_argv[1] = g_strdup ("-x");
676     }
677   else
678     {
679       if (check == NULL)
680         check = g_find_program_in_path ("nxterm");
681       if (check == NULL)
682         check = g_find_program_in_path ("color-xterm");
683       if (check == NULL)
684         check = g_find_program_in_path ("rxvt");
685       if (check == NULL)
686         check = g_find_program_in_path ("xterm");
687       if (check == NULL)
688         check = g_find_program_in_path ("dtterm");
689       if (check == NULL)
690         {
691           check = g_strdup ("xterm");
692           g_warning ("couldn't find a terminal, falling back to xterm");
693         }
694       term_argv[0] = check;
695       term_argv[1] = g_strdup ("-e");
696     }
697
698   real_argc = term_argc + *argc;
699   real_argv = g_new (char *, real_argc + 1);
700   
701   for (i = 0; i < term_argc; i++)
702     real_argv[i] = term_argv[i];
703   
704   for (j = 0; j < *argc; j++, i++)
705     real_argv[i] = (char *)the_argv[j];
706   
707   real_argv[i] = NULL;
708   
709   g_free (*argv);
710   *argv = real_argv;
711   *argc = real_argc;
712   
713   /* we use g_free here as we sucked all the inner strings
714    * out from it into real_argv */
715   g_free (term_argv);
716   return TRUE;
717 #else
718   return FALSE;
719 #endif /* G_OS_WIN32 */
720 }
721
722 /* '=' is the new '\0'.
723  * DO NOT CALL unless at least one string ends with '='
724  */
725 static gboolean
726 is_env (const char *a,
727         const char *b)
728 {
729   while (*a == *b)
730   {
731     if (*a == 0 || *b == 0)
732       return FALSE;
733     
734     if (*a == '=')
735       return TRUE;
736
737     a++;
738     b++;
739   }
740
741   return FALSE;
742 }
743
744 /* free with g_strfreev */
745 static char **
746 replace_env_var (char       **old_environ,
747                  const char  *env_var,
748                  const char  *new_value)
749 {
750   int length, new_length;
751   int index, new_index;
752   char **new_environ;
753   int i, new_i;
754
755   /* do two things at once:
756    *  - discover the length of the environment ('length')
757    *  - find the location (if any) of the env var ('index')
758    */
759   index = -1;
760   for (length = 0; old_environ[length]; length++)
761     {
762       /* if we already have it in our environment, replace */
763       if (is_env (old_environ[length], env_var))
764         index = length;
765     }
766
767   
768   /* no current env var, no desired env value.
769    * this is easy :)
770    */
771   if (new_value == NULL && index == -1)
772     return old_environ;
773
774   /* in all cases now, we will be using a modified environment.
775    * determine its length and allocated it.
776    * 
777    * after this block:
778    *   new_index   = location to insert, if any
779    *   new_length  = length of the new array
780    *   new_environ = the pointer array for the new environment
781    */
782   
783   if (new_value == NULL && index >= 0)
784     {
785       /* in this case, we will be removing an entry */
786       new_length = length - 1;
787       new_index = -1;
788     }
789   else if (new_value != NULL && index < 0)
790     {
791       /* in this case, we will be adding an entry to the end */
792       new_length = length + 1;
793       new_index = length;
794     }
795   else
796     /* in this case, we will be replacing the existing entry */
797     {
798       new_length = length;
799       new_index = index;
800     }
801
802   new_environ = g_malloc (sizeof (char *) * (new_length + 1));
803   new_environ[new_length] = NULL;
804
805   /* now we do the copying.
806    * for each entry in the new environment, we decide what to do
807    */
808   
809   i = 0;
810   for (new_i = 0; new_i < new_length; new_i++)
811     {
812       if (new_i == new_index)
813         {
814           /* insert our new item */
815           new_environ[new_i] = g_strconcat (env_var,
816                                             "=",
817                                             new_value,
818                                             NULL);
819           
820           /* if we had an old entry, skip it now */
821           if (index >= 0)
822             i++;
823         }
824       else
825         {
826           /* if this is the old DESKTOP_STARTUP_ID, skip it */
827           if (i == index)
828             i++;
829           
830           /* copy an old item */
831           new_environ[new_i] = g_strdup (old_environ[i]);
832           i++;
833         }
834     }
835
836   g_strfreev (old_environ);
837   
838   return new_environ;
839 }
840
841 static GList *
842 uri_list_segment_to_files (GList *start,
843                            GList *end)
844 {
845   GList *res;
846   GFile *file;
847
848   res = NULL;
849   while (start != NULL && start != end)
850     {
851       file = g_file_new_for_uri ((char *)start->data);
852       res = g_list_prepend (res, file);
853       start = start->next;
854     }
855
856   return g_list_reverse (res);
857 }
858
859 #ifdef HAVE__NSGETENVIRON
860 #define environ (*_NSGetEnviron())
861 #elif !defined(G_OS_WIN32)
862
863 /* According to the Single Unix Specification, environ is not in 
864  *  * any system header, although unistd.h often declares it.
865  *   */
866 extern char **environ;
867 #endif
868
869 static gboolean
870 g_desktop_app_info_launch_uris (GAppInfo           *appinfo,
871                                 GList              *uris,
872                                 GAppLaunchContext  *launch_context,
873                                 GError            **error)
874 {
875   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
876   gboolean completed = FALSE;
877   GList *old_uris;
878   GList *launched_files;
879   char **envp;
880   char **argv;
881   int argc;
882   char *display;
883   char *sn_id;
884
885   g_return_val_if_fail (appinfo != NULL, FALSE);
886
887   argv = NULL;
888   envp = NULL;
889       
890   do 
891     {
892       old_uris = uris;
893       if (!expand_application_parameters (info, &uris,
894                                           &argc, &argv, error))
895         goto out;
896       
897       if (info->terminal && !prepend_terminal_to_vector (&argc, &argv))
898         {
899           g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
900                                _("Unable to find terminal required for application"));
901           goto out;
902         }
903
904       sn_id = NULL;
905       if (launch_context)
906         {
907           launched_files = uri_list_segment_to_files (old_uris, uris);
908           
909           display = g_app_launch_context_get_display (launch_context,
910                                                       appinfo,
911                                                       launched_files);
912
913           sn_id = NULL;
914           if (info->startup_notify)
915             sn_id = g_app_launch_context_get_startup_notify_id (launch_context,
916                                                                 appinfo,
917                                                                 launched_files);
918           
919           if (display || sn_id)
920             {
921 #ifdef G_OS_WIN32
922               /* FIXME */
923               envp = g_new0 (char *, 1);
924 #else
925               envp = g_strdupv (environ);
926 #endif
927               
928               if (display)
929                 envp = replace_env_var (envp,
930                                         "DISPLAY",
931                                         display);
932               
933               if (sn_id)
934                 envp = replace_env_var (envp,
935                                         "DESKTOP_STARTUP_ID",
936                                         sn_id);
937             }
938
939           g_free (display);
940           
941           g_list_foreach (launched_files, (GFunc)g_object_unref, NULL);
942           g_list_free (launched_files);
943         }
944       
945       if (!g_spawn_async (info->path,  /* working directory */
946                           argv,
947                           envp,
948                           G_SPAWN_SEARCH_PATH /* flags */,
949                           NULL /* child_setup */,
950                           NULL /* data */,
951                           NULL /* child_pid */,
952                           error))
953         {
954           if (sn_id)
955             {
956               g_app_launch_context_launch_failed (launch_context, sn_id);
957               g_free (sn_id);
958             }
959           goto out;
960         }
961
962       
963       g_free (sn_id);
964       
965       g_strfreev (envp);
966       g_strfreev (argv);
967       envp = NULL;
968       argv = NULL;
969     }
970   while (uris != NULL);
971
972   completed = TRUE;
973
974  out:
975   g_strfreev (argv);
976   g_strfreev (envp);
977
978   return completed;
979 }
980
981 static gboolean
982 g_desktop_app_info_supports_uris (GAppInfo *appinfo)
983 {
984   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
985  
986   return info->exec && 
987     ((strstr (info->exec, "%u") != NULL) ||
988      (strstr (info->exec, "%U") != NULL));
989 }
990
991 static gboolean
992 g_desktop_app_info_supports_files (GAppInfo *appinfo)
993 {
994   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
995  
996   return info->exec && 
997     ((strstr (info->exec, "%f") != NULL) ||
998      (strstr (info->exec, "%F") != NULL));
999 }
1000
1001 static gboolean
1002 g_desktop_app_info_launch (GAppInfo           *appinfo,
1003                            GList              *files,
1004                            GAppLaunchContext  *launch_context,
1005                            GError            **error)
1006 {
1007   GList *uris;
1008   char *uri;
1009   gboolean res;
1010
1011   uris = NULL;
1012   while (files)
1013     {
1014       uri = g_file_get_uri (files->data);
1015       uris = g_list_prepend (uris, uri);
1016       files = files->next;
1017     }
1018   
1019   uris = g_list_reverse (uris);
1020   
1021   res = g_desktop_app_info_launch_uris (appinfo, uris, launch_context, error);
1022   
1023   g_list_foreach  (uris, (GFunc)g_free, NULL);
1024   g_list_free (uris);
1025   
1026   return res;
1027 }
1028
1029 G_LOCK_DEFINE_STATIC (g_desktop_env);
1030 static gchar *g_desktop_env = NULL;
1031
1032 /**
1033  * g_desktop_app_info_set_desktop_env:
1034  * @desktop_env: a string specifying what desktop this is
1035  *
1036  * Sets the name of the desktop that the application is running in.
1037  * This is used by g_app_info_should_show() to evaluate the
1038  * <literal>OnlyShowIn</literal> and <literal>NotShowIn</literal>
1039  * desktop entry fields.
1040  *
1041  * The <ulink url="http://standards.freedesktop.org/menu-spec/latest/">Desktop 
1042  * Menu specification</ulink> recognizes the following:
1043  * <simplelist>
1044  *   <member>GNOME</member>
1045  *   <member>KDE</member>
1046  *   <member>ROX</member>
1047  *   <member>XFCE</member>
1048  *   <member>Old</member> 
1049  * </simplelist>
1050  *
1051  * Should be called only once; subsequent calls are ignored.
1052  */
1053 void
1054 g_desktop_app_info_set_desktop_env (const gchar *desktop_env)
1055 {
1056   G_LOCK (g_desktop_env);
1057   if (!g_desktop_env)
1058     g_desktop_env = g_strdup (desktop_env);
1059   G_UNLOCK (g_desktop_env);
1060 }
1061
1062 static gboolean
1063 g_desktop_app_info_should_show (GAppInfo *appinfo)
1064 {
1065   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
1066   gboolean found;
1067   const gchar *desktop_env;
1068   int i;
1069
1070   if (info->nodisplay)
1071     return FALSE;
1072
1073   G_LOCK (g_desktop_env);
1074   desktop_env = g_desktop_env;
1075   G_UNLOCK (g_desktop_env);
1076
1077   if (info->only_show_in)
1078     {
1079       if (desktop_env == NULL)
1080         return FALSE;
1081       
1082       found = FALSE;
1083       for (i = 0; info->only_show_in[i] != NULL; i++)
1084         {
1085           if (strcmp (info->only_show_in[i], desktop_env) == 0)
1086             {
1087               found = TRUE;
1088               break;
1089             }
1090         }
1091       if (!found)
1092         return FALSE;
1093     }
1094
1095   if (info->not_show_in && desktop_env)
1096     {
1097       for (i = 0; info->not_show_in[i] != NULL; i++)
1098         {
1099           if (strcmp (info->not_show_in[i], desktop_env) == 0)
1100             return FALSE;
1101         }
1102     }
1103   
1104   return TRUE;
1105 }
1106
1107 typedef enum {
1108   APP_DIR,
1109   MIMETYPE_DIR
1110 } DirType;
1111
1112 static char *
1113 ensure_dir (DirType   type,
1114             GError  **error)
1115 {
1116   char *path, *display_name;
1117   int errsv;
1118
1119   if (type == APP_DIR)
1120     path = g_build_filename (g_get_user_data_dir (), "applications", NULL);
1121   else
1122     path = g_build_filename (g_get_user_data_dir (), "mime", "packages", NULL);
1123
1124   errno = 0;
1125   if (g_mkdir_with_parents (path, 0700) == 0)
1126     return path;
1127
1128   errsv = errno;
1129   display_name = g_filename_display_name (path);
1130   if (type == APP_DIR)
1131     g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
1132                  _("Can't create user application configuration folder %s: %s"),
1133                  display_name, g_strerror (errsv));
1134   else
1135     g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
1136                  _("Can't create user MIME configuration folder %s: %s"),
1137                  display_name, g_strerror (errsv));
1138
1139   g_free (display_name);
1140   g_free (path);
1141
1142   return NULL;
1143 }
1144
1145 static gboolean
1146 update_mimeapps_list (const char  *desktop_id, 
1147                       const char  *content_type, 
1148                       gboolean     add_at_start, 
1149                       gboolean     add_at_end, 
1150                       gboolean     remove, 
1151                       GError     **error)
1152 {
1153   char *dirname, *filename;
1154   GKeyFile *key_file;
1155   gboolean load_succeeded, res;
1156   char **old_list;
1157   char **list;
1158   gsize length, data_size;
1159   char *data;
1160   int i, j;
1161
1162   /* Don't add both at start and end */
1163   g_assert (!(add_at_start && add_at_end));
1164   
1165   dirname = ensure_dir (APP_DIR, error);
1166   if (!dirname)
1167     return FALSE;
1168
1169   filename = g_build_filename (dirname, "mimeapps.list", NULL);
1170   g_free (dirname);
1171
1172   key_file = g_key_file_new ();
1173   load_succeeded = g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, NULL);
1174   if (!load_succeeded || !g_key_file_has_group (key_file, ADDED_ASSOCIATIONS_GROUP))
1175     {
1176       g_key_file_free (key_file);
1177       key_file = g_key_file_new ();
1178     }
1179
1180   /* Add to the right place in the list */
1181   
1182   length = 0;
1183   old_list = g_key_file_get_string_list (key_file, ADDED_ASSOCIATIONS_GROUP,
1184                                          content_type, &length, NULL);
1185
1186   list = g_new (char *, 1 + length + 1);
1187
1188   i = 0;
1189   if (add_at_start)
1190     list[i++] = g_strdup (desktop_id);
1191   if (old_list)
1192     {
1193       for (j = 0; old_list[j] != NULL; j++)
1194         {
1195           if (strcmp (old_list[j], desktop_id) != 0)
1196             list[i++] = g_strdup (old_list[j]);
1197         }
1198     }
1199   if (add_at_end)
1200     list[i++] = g_strdup (desktop_id);
1201   list[i] = NULL;
1202   
1203   g_strfreev (old_list);
1204
1205   g_key_file_set_string_list (key_file,
1206                               ADDED_ASSOCIATIONS_GROUP,
1207                               content_type,
1208                               (const char * const *)list, i);
1209
1210   g_strfreev (list);
1211
1212   /* Remove from removed associations group (unless remove) */
1213   
1214   length = 0;
1215   old_list = g_key_file_get_string_list (key_file, REMOVED_ASSOCIATIONS_GROUP,
1216                                          content_type, &length, NULL);
1217
1218   list = g_new (char *, 1 + length + 1);
1219
1220   i = 0;
1221   if (remove)
1222     list[i++] = g_strdup (desktop_id);
1223   if (old_list)
1224     {
1225       for (j = 0; old_list[j] != NULL; j++)
1226         {
1227           if (strcmp (old_list[j], desktop_id) != 0)
1228             list[i++] = g_strdup (old_list[j]);
1229         }
1230     }
1231   list[i] = NULL;
1232   
1233   g_strfreev (old_list);
1234
1235   if (list[0] == NULL)
1236     g_key_file_remove_key (key_file,
1237                            REMOVED_ASSOCIATIONS_GROUP,
1238                            content_type,
1239                            NULL);
1240   else
1241     g_key_file_set_string_list (key_file,
1242                                 REMOVED_ASSOCIATIONS_GROUP,
1243                                 content_type,
1244                                 (const char * const *)list, i);
1245
1246   g_strfreev (list);
1247
1248   
1249   data = g_key_file_to_data (key_file, &data_size, error);
1250   g_key_file_free (key_file);
1251   
1252   res = g_file_set_contents (filename, data, data_size, error);
1253
1254   mime_info_cache_reload (NULL);
1255                           
1256   g_free (filename);
1257   g_free (data);
1258   
1259   return res;
1260 }
1261
1262 static gboolean
1263 g_desktop_app_info_set_as_default_for_type (GAppInfo    *appinfo,
1264                                             const char  *content_type,
1265                                             GError     **error)
1266 {
1267   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
1268
1269   if (!g_desktop_app_info_ensure_saved (info, error))
1270     return FALSE;  
1271   
1272   return update_mimeapps_list (info->desktop_id, content_type, TRUE, FALSE, FALSE, error);
1273 }
1274
1275 static void
1276 update_program_done (GPid     pid,
1277                      gint     status,
1278                      gpointer data)
1279 {
1280   /* Did the application exit correctly */
1281   if (WIFEXITED (status) &&
1282       WEXITSTATUS (status) == 0)
1283     {
1284       /* Here we could clean out any caches in use */
1285     }
1286 }
1287
1288 static void
1289 run_update_command (char *command,
1290                     char *subdir)
1291 {
1292         char *argv[3] = {
1293                 NULL,
1294                 NULL,
1295                 NULL,
1296         };
1297         GPid pid = 0;
1298         GError *error = NULL;
1299
1300         argv[0] = command;
1301         argv[1] = g_build_filename (g_get_user_data_dir (), subdir, NULL);
1302
1303         if (g_spawn_async ("/", argv,
1304                            NULL,       /* envp */
1305                            G_SPAWN_SEARCH_PATH |
1306                            G_SPAWN_STDOUT_TO_DEV_NULL |
1307                            G_SPAWN_STDERR_TO_DEV_NULL |
1308                            G_SPAWN_DO_NOT_REAP_CHILD,
1309                            NULL, NULL, /* No setup function */
1310                            &pid,
1311                            NULL)) 
1312           g_child_watch_add (pid, update_program_done, NULL);
1313         else
1314           {
1315             /* If we get an error at this point, it's quite likely the user doesn't
1316              * have an installed copy of either 'update-mime-database' or
1317              * 'update-desktop-database'.  I don't think we want to popup an error
1318              * dialog at this point, so we just do a g_warning to give the user a
1319              * chance of debugging it.
1320              */
1321             g_warning ("%s", error->message);
1322           }
1323         
1324         g_free (argv[1]);
1325 }
1326
1327 static gboolean
1328 g_desktop_app_info_set_as_default_for_extension (GAppInfo    *appinfo,
1329                                                  const char  *extension,
1330                                                  GError     **error)
1331 {
1332   char *filename, *basename, *mimetype;
1333   char *dirname;
1334   gboolean res;
1335
1336   if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (appinfo), error))
1337     return FALSE;  
1338   
1339   dirname = ensure_dir (MIMETYPE_DIR, error);
1340   if (!dirname)
1341     return FALSE;
1342   
1343   basename = g_strdup_printf ("user-extension-%s.xml", extension);
1344   filename = g_build_filename (dirname, basename, NULL);
1345   g_free (basename);
1346   g_free (dirname);
1347
1348   mimetype = g_strdup_printf ("application/x-extension-%s", extension);
1349   
1350   if (!g_file_test (filename, G_FILE_TEST_EXISTS)) 
1351     {
1352       char *contents;
1353
1354       contents =
1355         g_strdup_printf ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
1356                          "<mime-info xmlns=\"http://www.freedesktop.org/standards/shared-mime-info\">\n"
1357                          " <mime-type type=\"%s\">\n"
1358                          "  <comment>%s document</comment>\n"
1359                          "  <glob pattern=\"*.%s\"/>\n"
1360                          " </mime-type>\n"
1361                          "</mime-info>\n", mimetype, extension, extension);
1362
1363       g_file_set_contents (filename, contents, -1, NULL);
1364       g_free (contents);
1365
1366       run_update_command ("update-mime-database", "mime");
1367     }
1368   g_free (filename);
1369   
1370   res = g_desktop_app_info_set_as_default_for_type (appinfo,
1371                                                     mimetype,
1372                                                     error);
1373
1374   g_free (mimetype);
1375   
1376   return res;
1377 }
1378
1379 static gboolean
1380 g_desktop_app_info_add_supports_type (GAppInfo    *appinfo,
1381                                       const char  *content_type,
1382                                       GError     **error)
1383 {
1384   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
1385
1386   if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (info), error))
1387     return FALSE;  
1388   
1389   return update_mimeapps_list (info->desktop_id, content_type, FALSE, TRUE, FALSE, error);
1390 }
1391
1392 static gboolean
1393 g_desktop_app_info_can_remove_supports_type (GAppInfo *appinfo)
1394 {
1395   return TRUE;
1396 }
1397
1398 static gboolean
1399 g_desktop_app_info_remove_supports_type (GAppInfo    *appinfo,
1400                                          const char  *content_type,
1401                                          GError     **error)
1402 {
1403   GDesktopAppInfo *info = G_DESKTOP_APP_INFO (appinfo);
1404
1405   if (!g_desktop_app_info_ensure_saved (G_DESKTOP_APP_INFO (info), error))
1406     return FALSE;
1407   
1408   return update_mimeapps_list (info->desktop_id, content_type, FALSE, FALSE, TRUE, error);
1409 }
1410
1411 static gboolean
1412 g_desktop_app_info_ensure_saved (GDesktopAppInfo *info,
1413                                  GError **error)
1414 {
1415   GKeyFile *key_file;
1416   char *dirname;
1417   char *filename;
1418   char *data, *desktop_id;
1419   gsize data_size;
1420   int fd;
1421   gboolean res;
1422   
1423   if (info->filename != NULL)
1424     return TRUE;
1425
1426   /* This is only used for object created with
1427    * g_app_info_create_from_commandline. All other
1428    * object should have a filename
1429    */
1430   
1431   dirname = ensure_dir (APP_DIR, error);
1432   if (!dirname)
1433     return FALSE;
1434   
1435   key_file = g_key_file_new ();
1436
1437   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1438                          "Encoding", "UTF-8");
1439   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1440                          G_KEY_FILE_DESKTOP_KEY_VERSION, "1.0");
1441   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1442                          G_KEY_FILE_DESKTOP_KEY_TYPE,
1443                          G_KEY_FILE_DESKTOP_TYPE_APPLICATION);
1444   if (info->terminal) 
1445     g_key_file_set_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP,
1446                             G_KEY_FILE_DESKTOP_KEY_TERMINAL, TRUE);
1447
1448   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1449                          G_KEY_FILE_DESKTOP_KEY_EXEC, info->exec);
1450
1451   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1452                          G_KEY_FILE_DESKTOP_KEY_NAME, info->name);
1453
1454   g_key_file_set_string (key_file, G_KEY_FILE_DESKTOP_GROUP,
1455                          G_KEY_FILE_DESKTOP_KEY_COMMENT, info->comment);
1456   
1457   g_key_file_set_boolean (key_file, G_KEY_FILE_DESKTOP_GROUP,
1458                           G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, TRUE);
1459
1460   data = g_key_file_to_data (key_file, &data_size, NULL);
1461   g_key_file_free (key_file);
1462
1463   desktop_id = g_strdup_printf ("userapp-%s-XXXXXX.desktop", info->name);
1464   filename = g_build_filename (dirname, desktop_id, NULL);
1465   g_free (desktop_id);
1466   g_free (dirname);
1467   
1468   fd = g_mkstemp (filename);
1469   if (fd == -1)
1470     {
1471       char *display_name;
1472
1473       display_name = g_filename_display_name (filename);
1474       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
1475                    _("Can't create user desktop file %s"), display_name);
1476       g_free (display_name);
1477       g_free (filename);
1478       g_free (data);
1479       return FALSE;
1480     }
1481
1482   desktop_id = g_path_get_basename (filename);
1483
1484   close (fd);
1485   
1486   res = g_file_set_contents (filename, data, data_size, error);
1487   if (!res)
1488     {
1489       g_free (desktop_id);
1490       g_free (filename);
1491       return FALSE;
1492     }
1493
1494   info->filename = filename;
1495   info->desktop_id = desktop_id;
1496   
1497   run_update_command ("update-desktop-database", "applications");
1498   
1499   return TRUE;
1500 }
1501
1502 /**
1503  * g_app_info_create_from_commandline:
1504  * @commandline: the commandline to use
1505  * @application_name: the application name, or %NULL to use @commandline
1506  * @flags: flags that can specify details of the created #GAppInfo
1507  * @error: a #GError location to store the error occuring, %NULL to ignore.
1508  *
1509  * Creates a new #GAppInfo from the given information.
1510  *
1511  * Returns: new #GAppInfo for given command.
1512  **/
1513 GAppInfo *
1514 g_app_info_create_from_commandline (const char           *commandline,
1515                                     const char           *application_name,
1516                                     GAppInfoCreateFlags   flags,
1517                                     GError              **error)
1518 {
1519   char **split;
1520   char *basename;
1521   GDesktopAppInfo *info;
1522
1523   info = g_object_new (G_TYPE_DESKTOP_APP_INFO, NULL);
1524
1525   info->filename = NULL;
1526   info->desktop_id = NULL;
1527   
1528   info->terminal = flags & G_APP_INFO_CREATE_NEEDS_TERMINAL;
1529   info->startup_notify = FALSE;
1530   info->hidden = FALSE;
1531   if (flags & G_APP_INFO_CREATE_SUPPORTS_URIS)
1532     info->exec = g_strconcat (commandline, " %u", NULL);
1533   else
1534     info->exec = g_strconcat (commandline, " %f", NULL);
1535   info->nodisplay = TRUE;
1536   info->binary = binary_from_exec (info->exec);
1537   
1538   if (application_name)
1539     info->name = g_strdup (application_name);
1540   else
1541     {
1542       /* FIXME: this should be more robust. Maybe g_shell_parse_argv and use argv[0] */
1543       split = g_strsplit (commandline, " ", 2);
1544       basename = g_path_get_basename (split[0]);
1545       g_strfreev (split);
1546       info->name = basename;
1547       if (info->name == NULL)
1548         info->name = g_strdup ("custom");
1549     }
1550   info->comment = g_strdup_printf (_("Custom definition for %s"), info->name);
1551   
1552   return G_APP_INFO (info);
1553 }
1554
1555 static void
1556 g_desktop_app_info_iface_init (GAppInfoIface *iface)
1557 {
1558   iface->dup = g_desktop_app_info_dup;
1559   iface->equal = g_desktop_app_info_equal;
1560   iface->get_id = g_desktop_app_info_get_id;
1561   iface->get_name = g_desktop_app_info_get_name;
1562   iface->get_description = g_desktop_app_info_get_description;
1563   iface->get_executable = g_desktop_app_info_get_executable;
1564   iface->get_icon = g_desktop_app_info_get_icon;
1565   iface->launch = g_desktop_app_info_launch;
1566   iface->supports_uris = g_desktop_app_info_supports_uris;
1567   iface->supports_files = g_desktop_app_info_supports_files;
1568   iface->launch_uris = g_desktop_app_info_launch_uris;
1569   iface->should_show = g_desktop_app_info_should_show;
1570   iface->set_as_default_for_type = g_desktop_app_info_set_as_default_for_type;
1571   iface->set_as_default_for_extension = g_desktop_app_info_set_as_default_for_extension;
1572   iface->add_supports_type = g_desktop_app_info_add_supports_type;
1573   iface->can_remove_supports_type = g_desktop_app_info_can_remove_supports_type;
1574   iface->remove_supports_type = g_desktop_app_info_remove_supports_type;
1575 }
1576
1577 static gboolean
1578 app_info_in_list (GAppInfo *info, 
1579                   GList    *list)
1580 {
1581   while (list != NULL)
1582     {
1583       if (g_app_info_equal (info, list->data))
1584         return TRUE;
1585       list = list->next;
1586     }
1587   return FALSE;
1588 }
1589
1590
1591 /**
1592  * g_app_info_get_all_for_type:
1593  * @content_type: the content type to find a #GAppInfo for
1594  * 
1595  * Gets a list of all #GAppInfo s for a given content type.
1596  *
1597  * Returns: #GList of #GAppInfo s for given @content_type
1598  *    or %NULL on error.
1599  **/
1600 GList *
1601 g_app_info_get_all_for_type (const char *content_type)
1602 {
1603   GList *desktop_entries, *l;
1604   GList *infos;
1605   GDesktopAppInfo *info;
1606
1607   g_return_val_if_fail (content_type != NULL, NULL);
1608   
1609   desktop_entries = get_all_desktop_entries_for_mime_type (content_type);
1610
1611   infos = NULL;
1612   for (l = desktop_entries; l != NULL; l = l->next)
1613     {
1614       char *desktop_entry = l->data;
1615
1616       info = g_desktop_app_info_new (desktop_entry);
1617       if (info)
1618         {
1619           if (app_info_in_list (G_APP_INFO (info), infos))
1620             g_object_unref (info);
1621           else
1622             infos = g_list_prepend (infos, info);
1623         }
1624       g_free (desktop_entry);
1625     }
1626
1627   g_list_free (desktop_entries);
1628   
1629   return g_list_reverse (infos);
1630 }
1631
1632
1633 /**
1634  * g_app_info_get_default_for_type:
1635  * @content_type: the content type to find a #GAppInfo for
1636  * @must_support_uris: if %TRUE, the #GAppInfo is expected to
1637  *     support URIs
1638  * 
1639  * Gets the #GAppInfo that correspond to a given content type.
1640  *
1641  * Returns: #GAppInfo for given @content_type or %NULL on error.
1642  **/
1643 GAppInfo *
1644 g_app_info_get_default_for_type (const char *content_type,
1645                                  gboolean    must_support_uris)
1646 {
1647   GList *desktop_entries, *l;
1648   GAppInfo *info;
1649
1650   g_return_val_if_fail (content_type != NULL, NULL);
1651   
1652   desktop_entries = get_all_desktop_entries_for_mime_type (content_type);
1653
1654   info = NULL;
1655   for (l = desktop_entries; l != NULL; l = l->next)
1656     {
1657       char *desktop_entry = l->data;
1658
1659       info = (GAppInfo *)g_desktop_app_info_new (desktop_entry);
1660       if (info)
1661         {
1662           if (must_support_uris && !g_app_info_supports_uris (info))
1663             {
1664               g_object_unref (info);
1665               info = NULL;
1666             }
1667           else
1668             break;
1669         }
1670     }
1671   
1672   g_list_foreach  (desktop_entries, (GFunc)g_free, NULL);
1673   g_list_free (desktop_entries);
1674   
1675   return info;
1676 }
1677
1678 /**
1679  * g_app_info_get_default_for_uri_scheme:
1680  * @uri_scheme: a string containing a URI scheme.
1681  *
1682  * Gets the default application for launching applications 
1683  * using this URI scheme. A URI scheme is the initial part 
1684  * of the URI, up to but not including the ':', e.g. "http", 
1685  * "ftp" or "sip".
1686  * 
1687  * Returns: #GAppInfo for given @uri_scheme or %NULL on error.
1688  **/
1689 GAppInfo *
1690 g_app_info_get_default_for_uri_scheme (const char *uri_scheme)
1691 {
1692   static gsize lookup = 0;
1693   
1694   if (g_once_init_enter (&lookup))
1695     {
1696       gsize setup_value = 1;
1697       GDesktopAppInfoLookup *lookup_instance;
1698       const char *use_this;
1699       GIOExtensionPoint *ep;
1700       GIOExtension *extension;
1701       GList *l;
1702
1703       use_this = g_getenv ("GIO_USE_URI_ASSOCIATION");
1704       
1705       /* Ensure vfs in modules loaded */
1706       _g_io_modules_ensure_loaded ();
1707       
1708       ep = g_io_extension_point_lookup (G_DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME);
1709
1710       lookup_instance = NULL;
1711       if (use_this)
1712         {
1713           extension = g_io_extension_point_get_extension_by_name (ep, use_this);
1714           if (extension)
1715             lookup_instance = g_object_new (g_io_extension_get_type (extension), NULL);
1716         }
1717       
1718       if (lookup_instance == NULL)
1719         {
1720           for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
1721             {
1722               extension = l->data;
1723               lookup_instance = g_object_new (g_io_extension_get_type (extension), NULL);
1724               if (lookup_instance != NULL)
1725                 break;
1726             }
1727         }
1728
1729       if (lookup_instance != NULL)
1730         setup_value = (gsize)lookup_instance;
1731       
1732       g_once_init_leave (&lookup, setup_value);
1733     }
1734
1735   if (lookup == 1)
1736     return NULL;
1737
1738   return g_desktop_app_info_lookup_get_default_for_uri_scheme (G_DESKTOP_APP_INFO_LOOKUP (lookup),
1739                                                                uri_scheme);
1740 }
1741
1742
1743 static void
1744 get_apps_from_dir (GHashTable *apps, 
1745                    const char *dirname, 
1746                    const char *prefix)
1747 {
1748   GDir *dir;
1749   const char *basename;
1750   char *filename, *subprefix, *desktop_id;
1751   gboolean hidden;
1752   GDesktopAppInfo *appinfo;
1753   
1754   dir = g_dir_open (dirname, 0, NULL);
1755   if (dir)
1756     {
1757       while ((basename = g_dir_read_name (dir)) != NULL)
1758         {
1759           filename = g_build_filename (dirname, basename, NULL);
1760           if (g_str_has_suffix (basename, ".desktop"))
1761             {
1762               desktop_id = g_strconcat (prefix, basename, NULL);
1763
1764               /* Use _extended so we catch NULLs too (hidden) */
1765               if (!g_hash_table_lookup_extended (apps, desktop_id, NULL, NULL))
1766                 {
1767                   appinfo = g_desktop_app_info_new_from_filename (filename);
1768
1769                   if (appinfo && g_desktop_app_info_get_is_hidden (appinfo))
1770                     {
1771                       g_object_unref (appinfo);
1772                       appinfo = NULL;
1773                       hidden = TRUE;
1774                     }
1775                                       
1776                   if (appinfo || hidden)
1777                     {
1778                       g_hash_table_insert (apps, g_strdup (desktop_id), appinfo);
1779
1780                       if (appinfo)
1781                         {
1782                           /* Reuse instead of strdup here */
1783                           appinfo->desktop_id = desktop_id;
1784                           desktop_id = NULL;
1785                         }
1786                     }
1787                 }
1788               g_free (desktop_id);
1789             }
1790           else
1791             {
1792               if (g_file_test (filename, G_FILE_TEST_IS_DIR))
1793                 {
1794                   subprefix = g_strconcat (prefix, basename, "-", NULL);
1795                   get_apps_from_dir (apps, filename, subprefix);
1796                   g_free (subprefix);
1797                 }
1798             }
1799           g_free (filename);
1800         }
1801       g_dir_close (dir);
1802     }
1803 }
1804
1805
1806 /**
1807  * g_app_info_get_all:
1808  *
1809  * Gets a list of all of the applications currently registered 
1810  * on this system.
1811  * 
1812  * For desktop files, this includes applications that have 
1813  * <literal>NoDisplay=true</literal> set or are excluded from 
1814  * display by means of <literal>OnlyShowIn</literal> or
1815  * <literal>NotShowIn</literal>. See g_app_info_should_show().
1816  * The returned list does not include applications which have
1817  * the <literal>Hidden</literal> key set. 
1818  * 
1819  * Returns: a newly allocated #GList of references to #GAppInfo<!---->s.
1820  **/
1821 GList *
1822 g_app_info_get_all (void)
1823 {
1824   const char * const *dirs;
1825   GHashTable *apps;
1826   GHashTableIter iter;
1827   gpointer value;
1828   int i;
1829   GList *infos;
1830
1831   dirs = get_applications_search_path ();
1832
1833   apps = g_hash_table_new_full (g_str_hash, g_str_equal,
1834                                 g_free, NULL);
1835
1836   
1837   for (i = 0; dirs[i] != NULL; i++)
1838     get_apps_from_dir (apps, dirs[i], "");
1839
1840
1841   infos = NULL;
1842   g_hash_table_iter_init (&iter, apps);
1843   while (g_hash_table_iter_next (&iter, NULL, &value))
1844     {
1845       if (value)
1846         infos = g_list_prepend (infos, value);
1847     }
1848
1849   g_hash_table_destroy (apps);
1850
1851   return g_list_reverse (infos);
1852 }
1853
1854 /* Cacheing of mimeinfo.cache and defaults.list files */
1855
1856 typedef struct {
1857   char *path;
1858   GHashTable *mime_info_cache_map;
1859   GHashTable *defaults_list_map;
1860   GHashTable *mimeapps_list_added_map;
1861   GHashTable *mimeapps_list_removed_map;
1862   time_t mime_info_cache_timestamp;
1863   time_t defaults_list_timestamp;
1864   time_t mimeapps_list_timestamp;
1865 } MimeInfoCacheDir;
1866
1867 typedef struct {
1868   GList *dirs;                       /* mimeinfo.cache and defaults.list */
1869   GHashTable *global_defaults_cache; /* global results of defaults.list lookup and validation */
1870   time_t last_stat_time;
1871   guint should_ping_mime_monitor : 1;
1872 } MimeInfoCache;
1873
1874 static MimeInfoCache *mime_info_cache = NULL;
1875 G_LOCK_DEFINE_STATIC (mime_info_cache);
1876
1877 static void mime_info_cache_dir_add_desktop_entries (MimeInfoCacheDir  *dir,
1878                                                      const char        *mime_type,
1879                                                      char             **new_desktop_file_ids);
1880
1881 static MimeInfoCache * mime_info_cache_new (void);
1882
1883 static void
1884 destroy_info_cache_value (gpointer  key, 
1885                           GList    *value, 
1886                           gpointer  data)
1887 {
1888   g_list_foreach (value, (GFunc)g_free, NULL);
1889   g_list_free (value);
1890 }
1891
1892 static void
1893 destroy_info_cache_map (GHashTable *info_cache_map)
1894 {
1895   g_hash_table_foreach (info_cache_map, (GHFunc)destroy_info_cache_value, NULL);
1896   g_hash_table_destroy (info_cache_map);
1897 }
1898
1899 static gboolean
1900 mime_info_cache_dir_out_of_date (MimeInfoCacheDir *dir,
1901                                  const char       *cache_file,
1902                                  time_t           *timestamp)
1903 {
1904   struct stat buf;
1905   char *filename;
1906   
1907   filename = g_build_filename (dir->path, cache_file, NULL);
1908   
1909   if (g_stat (filename, &buf) < 0)
1910     {
1911       g_free (filename);
1912       return TRUE;
1913     }
1914   g_free (filename);
1915
1916   if (buf.st_mtime != *timestamp) 
1917     return TRUE;
1918   
1919   return FALSE;
1920 }
1921
1922 /* Call with lock held */
1923 static gboolean
1924 remove_all (gpointer  key,
1925             gpointer  value,
1926             gpointer  user_data)
1927 {
1928   return TRUE;
1929 }
1930
1931
1932 static void
1933 mime_info_cache_blow_global_cache (void)
1934 {
1935   g_hash_table_foreach_remove (mime_info_cache->global_defaults_cache,
1936                                remove_all, NULL);
1937 }
1938
1939 static void
1940 mime_info_cache_dir_init (MimeInfoCacheDir *dir)
1941 {
1942   GError *load_error;
1943   GKeyFile *key_file;
1944   gchar *filename, **mime_types;
1945   int i;
1946   struct stat buf;
1947   
1948   load_error = NULL;
1949   mime_types = NULL;
1950   
1951   if (dir->mime_info_cache_map != NULL &&
1952       !mime_info_cache_dir_out_of_date (dir, "mimeinfo.cache",
1953                                         &dir->mime_info_cache_timestamp))
1954     return;
1955   
1956   if (dir->mime_info_cache_map != NULL)
1957     destroy_info_cache_map (dir->mime_info_cache_map);
1958   
1959   dir->mime_info_cache_map = g_hash_table_new_full (g_str_hash, g_str_equal,
1960                                                     (GDestroyNotify) g_free,
1961                                                     NULL);
1962   
1963   key_file = g_key_file_new ();
1964   
1965   filename = g_build_filename (dir->path, "mimeinfo.cache", NULL);
1966   
1967   if (g_stat (filename, &buf) < 0)
1968     goto error;
1969   
1970   if (dir->mime_info_cache_timestamp > 0) 
1971     mime_info_cache->should_ping_mime_monitor = TRUE;
1972   
1973   dir->mime_info_cache_timestamp = buf.st_mtime;
1974   
1975   g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, &load_error);
1976   
1977   g_free (filename);
1978   filename = NULL;
1979   
1980   if (load_error != NULL)
1981     goto error;
1982   
1983   mime_types = g_key_file_get_keys (key_file, MIME_CACHE_GROUP,
1984                                     NULL, &load_error);
1985   
1986   if (load_error != NULL)
1987     goto error;
1988   
1989   for (i = 0; mime_types[i] != NULL; i++)
1990     {
1991       gchar **desktop_file_ids;
1992       char *unaliased_type;
1993       desktop_file_ids = g_key_file_get_string_list (key_file,
1994                                                      MIME_CACHE_GROUP,
1995                                                      mime_types[i],
1996                                                      NULL,
1997                                                      NULL);
1998       
1999       if (desktop_file_ids == NULL)
2000         continue;
2001
2002       unaliased_type = _g_unix_content_type_unalias (mime_types[i]);
2003       mime_info_cache_dir_add_desktop_entries (dir,
2004                                                unaliased_type,
2005                                                desktop_file_ids);
2006       g_free (unaliased_type);
2007     
2008       g_strfreev (desktop_file_ids);
2009     }
2010   
2011   g_strfreev (mime_types);
2012   g_key_file_free (key_file);
2013   
2014   return;
2015  error:
2016   g_free (filename);
2017   g_key_file_free (key_file);
2018   
2019   if (mime_types != NULL)
2020     g_strfreev (mime_types);
2021   
2022   if (load_error)
2023     g_error_free (load_error);
2024 }
2025
2026 static void
2027 mime_info_cache_dir_init_defaults_list (MimeInfoCacheDir *dir)
2028 {
2029   GKeyFile *key_file;
2030   GError *load_error;
2031   gchar *filename, **mime_types;
2032   char *unaliased_type;
2033   char **desktop_file_ids;
2034   int i;
2035   struct stat buf;
2036
2037   load_error = NULL;
2038   mime_types = NULL;
2039
2040   if (dir->defaults_list_map != NULL &&
2041       !mime_info_cache_dir_out_of_date (dir, "defaults.list",
2042                                         &dir->defaults_list_timestamp))
2043     return;
2044   
2045   if (dir->defaults_list_map != NULL)
2046     g_hash_table_destroy (dir->defaults_list_map);
2047   dir->defaults_list_map = g_hash_table_new_full (g_str_hash, g_str_equal,
2048                                                   g_free, (GDestroyNotify)g_strfreev);
2049   
2050
2051   key_file = g_key_file_new ();
2052   
2053   filename = g_build_filename (dir->path, "defaults.list", NULL);
2054   if (g_stat (filename, &buf) < 0)
2055     goto error;
2056
2057   if (dir->defaults_list_timestamp > 0) 
2058     mime_info_cache->should_ping_mime_monitor = TRUE;
2059
2060   dir->defaults_list_timestamp = buf.st_mtime;
2061
2062   g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, &load_error);
2063   g_free (filename);
2064   filename = NULL;
2065
2066   if (load_error != NULL)
2067     goto error;
2068
2069   mime_types = g_key_file_get_keys (key_file, DEFAULT_APPLICATIONS_GROUP,
2070                                     NULL, NULL);
2071   if (mime_types != NULL)
2072     {
2073       for (i = 0; mime_types[i] != NULL; i++)
2074         {
2075           desktop_file_ids = g_key_file_get_string_list (key_file,
2076                                                          DEFAULT_APPLICATIONS_GROUP,
2077                                                          mime_types[i],
2078                                                          NULL,
2079                                                          NULL);
2080           if (desktop_file_ids == NULL)
2081             continue;
2082           
2083           unaliased_type = _g_unix_content_type_unalias (mime_types[i]);
2084           g_hash_table_replace (dir->defaults_list_map,
2085                                 unaliased_type,
2086                                 desktop_file_ids);
2087         }
2088       
2089       g_strfreev (mime_types);
2090     }
2091
2092   g_key_file_free (key_file);
2093   return;
2094   
2095  error:
2096   g_free (filename);
2097   g_key_file_free (key_file);
2098   
2099   if (mime_types != NULL)
2100     g_strfreev (mime_types);
2101   
2102   if (load_error)
2103     g_error_free (load_error);
2104 }
2105
2106 static void
2107 mime_info_cache_dir_init_mimeapps_list (MimeInfoCacheDir *dir)
2108 {
2109   GKeyFile *key_file;
2110   GError *load_error;
2111   gchar *filename, **mime_types;
2112   char *unaliased_type;
2113   char **desktop_file_ids;
2114   int i;
2115   struct stat buf;
2116
2117   load_error = NULL;
2118   mime_types = NULL;
2119
2120   if (dir->mimeapps_list_added_map != NULL &&
2121       !mime_info_cache_dir_out_of_date (dir, "mimeapps.list",
2122                                         &dir->mimeapps_list_timestamp))
2123     return;
2124   
2125   if (dir->mimeapps_list_added_map != NULL)
2126     g_hash_table_destroy (dir->mimeapps_list_added_map);
2127   dir->mimeapps_list_added_map = g_hash_table_new_full (g_str_hash, g_str_equal,
2128                                                         g_free, (GDestroyNotify)g_strfreev);
2129   
2130   if (dir->mimeapps_list_removed_map != NULL)
2131     g_hash_table_destroy (dir->mimeapps_list_removed_map);
2132   dir->mimeapps_list_removed_map = g_hash_table_new_full (g_str_hash, g_str_equal,
2133                                                           g_free, (GDestroyNotify)g_strfreev);
2134
2135   key_file = g_key_file_new ();
2136   
2137   filename = g_build_filename (dir->path, "mimeapps.list", NULL);
2138   if (g_stat (filename, &buf) < 0)
2139     goto error;
2140
2141   if (dir->mimeapps_list_timestamp > 0) 
2142     mime_info_cache->should_ping_mime_monitor = TRUE;
2143
2144   dir->mimeapps_list_timestamp = buf.st_mtime;
2145
2146   g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, &load_error);
2147   g_free (filename);
2148   filename = NULL;
2149
2150   if (load_error != NULL)
2151     goto error;
2152
2153   mime_types = g_key_file_get_keys (key_file, ADDED_ASSOCIATIONS_GROUP,
2154                                     NULL, NULL);
2155   if (mime_types != NULL)
2156     {
2157       for (i = 0; mime_types[i] != NULL; i++)
2158         {
2159           desktop_file_ids = g_key_file_get_string_list (key_file,
2160                                                          ADDED_ASSOCIATIONS_GROUP,
2161                                                          mime_types[i],
2162                                                          NULL,
2163                                                          NULL);
2164           if (desktop_file_ids == NULL)
2165             continue;
2166           
2167           unaliased_type = _g_unix_content_type_unalias (mime_types[i]);
2168           g_hash_table_replace (dir->mimeapps_list_added_map,
2169                                 unaliased_type,
2170                                 desktop_file_ids);
2171         }
2172       
2173       g_strfreev (mime_types);
2174     }
2175
2176   mime_types = g_key_file_get_keys (key_file, REMOVED_ASSOCIATIONS_GROUP,
2177                                     NULL, NULL);
2178   if (mime_types != NULL)
2179     {
2180       for (i = 0; mime_types[i] != NULL; i++)
2181         {
2182           desktop_file_ids = g_key_file_get_string_list (key_file,
2183                                                          REMOVED_ASSOCIATIONS_GROUP,
2184                                                          mime_types[i],
2185                                                          NULL,
2186                                                          NULL);
2187           if (desktop_file_ids == NULL)
2188             continue;
2189           
2190           unaliased_type = _g_unix_content_type_unalias (mime_types[i]);
2191           g_hash_table_replace (dir->mimeapps_list_removed_map,
2192                                 unaliased_type,
2193                                 desktop_file_ids);
2194         }
2195       
2196       g_strfreev (mime_types);
2197     }
2198
2199   g_key_file_free (key_file);
2200   return;
2201   
2202  error:
2203   g_free (filename);
2204   g_key_file_free (key_file);
2205   
2206   if (mime_types != NULL)
2207     g_strfreev (mime_types);
2208   
2209   if (load_error)
2210     g_error_free (load_error);
2211 }
2212
2213 static MimeInfoCacheDir *
2214 mime_info_cache_dir_new (const char *path)
2215 {
2216   MimeInfoCacheDir *dir;
2217
2218   dir = g_new0 (MimeInfoCacheDir, 1);
2219   dir->path = g_strdup (path);
2220   
2221   return dir;
2222 }
2223
2224 static void
2225 mime_info_cache_dir_free (MimeInfoCacheDir *dir)
2226 {
2227   if (dir == NULL)
2228     return;
2229   
2230   if (dir->mime_info_cache_map != NULL)
2231     {
2232       destroy_info_cache_map (dir->mime_info_cache_map);
2233       dir->mime_info_cache_map = NULL;
2234       
2235   }
2236   
2237   if (dir->defaults_list_map != NULL)
2238     {
2239       g_hash_table_destroy (dir->defaults_list_map);
2240       dir->defaults_list_map = NULL;
2241     }
2242   
2243   if (dir->mimeapps_list_added_map != NULL)
2244     {
2245       g_hash_table_destroy (dir->mimeapps_list_added_map);
2246       dir->mimeapps_list_added_map = NULL;
2247     }
2248   
2249   if (dir->mimeapps_list_removed_map != NULL)
2250     {
2251       g_hash_table_destroy (dir->mimeapps_list_removed_map);
2252       dir->mimeapps_list_removed_map = NULL;
2253     }
2254   
2255   g_free (dir);
2256 }
2257
2258 static void
2259 mime_info_cache_dir_add_desktop_entries (MimeInfoCacheDir  *dir,
2260                                          const char        *mime_type,
2261                                          char             **new_desktop_file_ids)
2262 {
2263   GList *desktop_file_ids;
2264   int i;
2265   
2266   desktop_file_ids = g_hash_table_lookup (dir->mime_info_cache_map,
2267                                           mime_type);
2268   
2269   for (i = 0; new_desktop_file_ids[i] != NULL; i++)
2270     {
2271       if (!g_list_find (desktop_file_ids, new_desktop_file_ids[i]))
2272         desktop_file_ids = g_list_append (desktop_file_ids,
2273                                           g_strdup (new_desktop_file_ids[i]));
2274     }
2275   
2276   g_hash_table_insert (dir->mime_info_cache_map, g_strdup (mime_type), desktop_file_ids);
2277 }
2278
2279 static void
2280 mime_info_cache_init_dir_lists (void)
2281 {
2282   const char * const *dirs;
2283   int i;
2284   
2285   mime_info_cache = mime_info_cache_new ();
2286   
2287   dirs = get_applications_search_path ();
2288   
2289   for (i = 0; dirs[i] != NULL; i++)
2290     {
2291       MimeInfoCacheDir *dir;
2292       
2293       dir = mime_info_cache_dir_new (dirs[i]);
2294       
2295       if (dir != NULL)
2296         {
2297           mime_info_cache_dir_init (dir);
2298           mime_info_cache_dir_init_defaults_list (dir);
2299           mime_info_cache_dir_init_mimeapps_list (dir);
2300           
2301           mime_info_cache->dirs = g_list_append (mime_info_cache->dirs, dir);
2302         }
2303     }
2304 }
2305
2306 static void
2307 mime_info_cache_update_dir_lists (void)
2308 {
2309   GList *tmp;
2310   
2311   tmp = mime_info_cache->dirs;
2312   
2313   while (tmp != NULL)
2314     {
2315       MimeInfoCacheDir *dir = (MimeInfoCacheDir *) tmp->data;
2316
2317       /* No need to do this if we had file monitors... */
2318       mime_info_cache_blow_global_cache ();
2319       mime_info_cache_dir_init (dir);
2320       mime_info_cache_dir_init_defaults_list (dir);
2321       mime_info_cache_dir_init_mimeapps_list (dir);
2322       
2323       tmp = tmp->next;
2324     }
2325 }
2326
2327 static void
2328 mime_info_cache_init (void)
2329 {
2330   G_LOCK (mime_info_cache);
2331   if (mime_info_cache == NULL)
2332     mime_info_cache_init_dir_lists ();
2333   else
2334     {
2335       time_t now;
2336       
2337       time (&now);
2338       if (now >= mime_info_cache->last_stat_time + 10)
2339         {
2340           mime_info_cache_update_dir_lists ();
2341           mime_info_cache->last_stat_time = now;
2342         }
2343     }
2344   
2345   if (mime_info_cache->should_ping_mime_monitor)
2346     {
2347       /* g_idle_add (emit_mime_changed, NULL); */
2348       mime_info_cache->should_ping_mime_monitor = FALSE;
2349     }
2350   
2351   G_UNLOCK (mime_info_cache);
2352 }
2353
2354 static MimeInfoCache *
2355 mime_info_cache_new (void)
2356 {
2357   MimeInfoCache *cache;
2358   
2359   cache = g_new0 (MimeInfoCache, 1);
2360   
2361   cache->global_defaults_cache = g_hash_table_new_full (g_str_hash, g_str_equal,
2362                                                         (GDestroyNotify) g_free,
2363                                                         (GDestroyNotify) g_free);
2364   return cache;
2365 }
2366
2367 static void
2368 mime_info_cache_free (MimeInfoCache *cache)
2369 {
2370   if (cache == NULL)
2371     return;
2372   
2373   g_list_foreach (cache->dirs,
2374                   (GFunc) mime_info_cache_dir_free,
2375                   NULL);
2376   g_list_free (cache->dirs);
2377   g_hash_table_destroy (cache->global_defaults_cache);
2378   g_free (cache);
2379 }
2380
2381 /**
2382  * mime_info_cache_reload:
2383  * @dir: directory path which needs reloading.
2384  * 
2385  * Reload the mime information for the @dir.
2386  */
2387 static void
2388 mime_info_cache_reload (const char *dir)
2389 {
2390   /* FIXME: just reload the dir that needs reloading,
2391    * don't blow the whole cache
2392    */
2393   if (mime_info_cache != NULL)
2394     {
2395       G_LOCK (mime_info_cache);
2396       mime_info_cache_free (mime_info_cache);
2397       mime_info_cache = NULL;
2398       G_UNLOCK (mime_info_cache);
2399     }
2400 }
2401
2402 static GList *
2403 append_desktop_entry (GList      *list, 
2404                       const char *desktop_entry,
2405                       GList      *removed_entries)
2406 {
2407   /* Add if not already in list, and valid */
2408   if (!g_list_find_custom (list, desktop_entry, (GCompareFunc) strcmp) &&
2409       !g_list_find_custom (removed_entries, desktop_entry, (GCompareFunc) strcmp))
2410     list = g_list_prepend (list, g_strdup (desktop_entry));
2411   
2412   return list;
2413 }
2414
2415 /**
2416  * get_all_desktop_entries_for_mime_type:
2417  * @mime_type: a mime type.
2418  *
2419  * Returns all the desktop ids for @mime_type. The desktop files
2420  * are listed in an order so that default applications are listed before
2421  * non-default ones, and handlers for inherited mimetypes are listed
2422  * after the base ones.
2423  *
2424  * Return value: a #GList containing the desktop ids which claim
2425  *    to handle @mime_type.
2426  */
2427 static GList *
2428 get_all_desktop_entries_for_mime_type (const char *base_mime_type)
2429 {
2430   GList *desktop_entries, *removed_entries, *list, *dir_list, *tmp;
2431   MimeInfoCacheDir *dir;
2432   char *mime_type;
2433   char **mime_types;
2434   char **default_entries;
2435   char **removed_associations;
2436   int i,j;
2437   
2438   mime_info_cache_init ();
2439
2440   mime_types = _g_unix_content_type_get_parents (base_mime_type);
2441   G_LOCK (mime_info_cache);
2442   
2443   removed_entries = NULL;
2444   desktop_entries = NULL;
2445   for (i = 0; mime_types[i] != NULL; i++)
2446     {
2447       mime_type = mime_types[i];
2448
2449       /* Go through all apps listed as defaults */
2450       for (dir_list = mime_info_cache->dirs;
2451            dir_list != NULL;
2452            dir_list = dir_list->next)
2453         {
2454           dir = dir_list->data;
2455
2456           /* First added associations from mimeapps.list */
2457           default_entries = g_hash_table_lookup (dir->mimeapps_list_added_map, mime_type);
2458           for (j = 0; default_entries != NULL && default_entries[j] != NULL; j++)
2459             desktop_entries = append_desktop_entry (desktop_entries, default_entries[j], removed_entries);
2460
2461           /* Then removed assiciations from mimeapps.list */
2462           removed_associations = g_hash_table_lookup (dir->mimeapps_list_removed_map, mime_type);
2463           for (j = 0; removed_associations != NULL && removed_associations[j] != NULL; j++)
2464             removed_entries = append_desktop_entry (removed_entries, removed_associations[j], NULL);
2465
2466           /* Then system defaults (or old per-user config) (using removed associations from this dir or earlier) */
2467           default_entries = g_hash_table_lookup (dir->defaults_list_map, mime_type);
2468           for (j = 0; default_entries != NULL && default_entries[j] != NULL; j++)
2469             desktop_entries = append_desktop_entry (desktop_entries, default_entries[j], removed_entries);
2470         }
2471
2472       /* Go through all entries that support the mimetype */
2473       for (dir_list = mime_info_cache->dirs;
2474            dir_list != NULL;
2475            dir_list = dir_list->next) 
2476         {
2477           dir = dir_list->data;
2478         
2479           list = g_hash_table_lookup (dir->mime_info_cache_map, mime_type);
2480           for (tmp = list; tmp != NULL; tmp = tmp->next)
2481             desktop_entries = append_desktop_entry (desktop_entries, tmp->data, removed_entries);
2482         }
2483     }
2484   
2485   G_UNLOCK (mime_info_cache);
2486
2487   g_strfreev (mime_types);
2488
2489   g_list_free (removed_entries);
2490   
2491   desktop_entries = g_list_reverse (desktop_entries);
2492   
2493   return desktop_entries;
2494 }
2495
2496 /* GDesktopAppInfoLookup interface: */
2497
2498 static void g_desktop_app_info_lookup_base_init (gpointer g_class);
2499 static void g_desktop_app_info_lookup_class_init (gpointer g_class,
2500                                                   gpointer class_data);
2501
2502 GType
2503 g_desktop_app_info_lookup_get_type (void)
2504 {
2505   static volatile gsize g_define_type_id__volatile = 0;
2506
2507   if (g_once_init_enter (&g_define_type_id__volatile))
2508     {
2509       const GTypeInfo desktop_app_info_lookup_info =
2510       {
2511         sizeof (GDesktopAppInfoLookupIface), /* class_size */
2512         g_desktop_app_info_lookup_base_init,   /* base_init */
2513         NULL,           /* base_finalize */
2514         g_desktop_app_info_lookup_class_init,
2515         NULL,           /* class_finalize */
2516         NULL,           /* class_data */
2517         0,
2518         0,              /* n_preallocs */
2519         NULL
2520       };
2521       GType g_define_type_id =
2522         g_type_register_static (G_TYPE_INTERFACE, I_("GDesktopAppInfoLookup"),
2523                                 &desktop_app_info_lookup_info, 0);
2524
2525       g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
2526
2527       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
2528     }
2529
2530   return g_define_type_id__volatile;
2531 }
2532
2533 static void
2534 g_desktop_app_info_lookup_class_init (gpointer g_class,
2535                                       gpointer class_data)
2536 {
2537 }
2538
2539 static void
2540 g_desktop_app_info_lookup_base_init (gpointer g_class)
2541 {
2542 }
2543
2544 /**
2545  * g_desktop_app_info_lookup_get_default_for_uri_scheme:
2546  * @lookup: a #GDesktopAppInfoLookup
2547  * @uri_scheme: a string containing a URI scheme.
2548  *
2549  * Gets the default application for launching applications 
2550  * using this URI scheme for a particular GDesktopAppInfoLookup
2551  * implementation.
2552  *
2553  * The GDesktopAppInfoLookup interface and this function is used
2554  * to implement g_app_info_get_default_for_uri_scheme() backends
2555  * in a GIO module. There is no reason for applications to use it
2556  * directly. Applications should use g_app_info_get_default_for_uri_scheme().
2557  * 
2558  * Returns: #GAppInfo for given @uri_scheme or %NULL on error.
2559  */
2560 GAppInfo *
2561 g_desktop_app_info_lookup_get_default_for_uri_scheme (GDesktopAppInfoLookup *lookup,
2562                                                       const char            *uri_scheme)
2563 {
2564   GDesktopAppInfoLookupIface *iface;
2565   
2566   g_return_val_if_fail (G_IS_DESKTOP_APP_INFO_LOOKUP (lookup), NULL);
2567
2568   iface = G_DESKTOP_APP_INFO_LOOKUP_GET_IFACE (lookup);
2569
2570   return (* iface->get_default_for_uri_scheme) (lookup, uri_scheme);
2571 }
2572
2573 #define __G_DESKTOP_APP_INFO_C__
2574 #include "gioaliasdef.c"