1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
3 /* GIO - GLib Input, Output and Streaming Library
5 * Copyright (C) 2006-2007 Red Hat, Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
22 * Author: Alexander Larsson <alexl@redhat.com>
26 #include <sys/types.h>
30 #include "gcontenttypeprivate.h"
31 #include "gthemedicon.h"
34 #include "gfileenumerator.h"
35 #include "gfileinfo.h"
40 * SECTION:gcontenttype
41 * @short_description: Platform-specific content typing
44 * A content type is a platform specific string that defines the type
45 * of a file. On UNIX it is a <ulink url="http://www.wikipedia.org/wiki/Internet_media_type">mime type</ulink> like "text/plain" or "image/png".
46 * On Win32 it is an extension string like ".doc", ".txt" or a perceived
47 * string like "audio". Such strings can be looked up in the registry at
53 #define XDG_PREFIX _gio_xdg
54 #include "xdgmime/xdgmime.h"
56 /* We lock this mutex whenever we modify global state in this module. */
57 G_LOCK_DEFINE_STATIC (gio_xdgmime
);
60 _g_unix_content_type_get_sniff_len (void)
65 size
= xdg_mime_get_max_buffer_extents ();
66 G_UNLOCK (gio_xdgmime
);
72 _g_unix_content_type_unalias (const gchar
*type
)
77 res
= g_strdup (xdg_mime_unalias_mime_type (type
));
78 G_UNLOCK (gio_xdgmime
);
84 _g_unix_content_type_get_parents (const gchar
*type
)
91 array
= g_ptr_array_new ();
95 umime
= xdg_mime_unalias_mime_type (type
);
97 g_ptr_array_add (array
, g_strdup (umime
));
99 parents
= xdg_mime_list_mime_parents (umime
);
100 for (i
= 0; parents
&& parents
[i
] != NULL
; i
++)
101 g_ptr_array_add (array
, g_strdup (parents
[i
]));
105 G_UNLOCK (gio_xdgmime
);
107 g_ptr_array_add (array
, NULL
);
109 return (gchar
**)g_ptr_array_free (array
, FALSE
);
113 * g_content_type_equals:
114 * @type1: a content type string
115 * @type2: a content type string
117 * Compares two content types for equality.
119 * Returns: %TRUE if the two strings are identical or equivalent,
123 g_content_type_equals (const gchar
*type1
,
128 g_return_val_if_fail (type1
!= NULL
, FALSE
);
129 g_return_val_if_fail (type2
!= NULL
, FALSE
);
131 G_LOCK (gio_xdgmime
);
132 res
= xdg_mime_mime_type_equal (type1
, type2
);
133 G_UNLOCK (gio_xdgmime
);
139 * g_content_type_is_a:
140 * @type: a content type string
141 * @supertype: a content type string
143 * Determines if @type is a subset of @supertype.
145 * Returns: %TRUE if @type is a kind of @supertype,
149 g_content_type_is_a (const gchar
*type
,
150 const gchar
*supertype
)
154 g_return_val_if_fail (type
!= NULL
, FALSE
);
155 g_return_val_if_fail (supertype
!= NULL
, FALSE
);
157 G_LOCK (gio_xdgmime
);
158 res
= xdg_mime_mime_type_subclass (type
, supertype
);
159 G_UNLOCK (gio_xdgmime
);
165 * g_content_type_is_unknown:
166 * @type: a content type string
168 * Checks if the content type is the generic "unknown" type.
169 * On UNIX this is the "application/octet-stream" mimetype,
170 * while on win32 it is "*".
172 * Returns: %TRUE if the type is the unknown type.
175 g_content_type_is_unknown (const gchar
*type
)
177 g_return_val_if_fail (type
!= NULL
, FALSE
);
179 return strcmp (XDG_MIME_TYPE_UNKNOWN
, type
) == 0;
185 MIME_TAG_TYPE_COMMENT
190 int current_lang_level
;
191 int comment_lang_level
;
197 language_level (const char *lang
)
199 const char * const *lang_list
;
202 /* The returned list is sorted from most desirable to least
203 desirable and always contains the default locale "C". */
204 lang_list
= g_get_language_names ();
206 for (i
= 0; lang_list
[i
]; i
++)
207 if (strcmp (lang_list
[i
], lang
) == 0)
214 mime_info_start_element (GMarkupParseContext
*context
,
215 const gchar
*element_name
,
216 const gchar
**attribute_names
,
217 const gchar
**attribute_values
,
223 MimeParser
*parser
= user_data
;
225 if (strcmp (element_name
, "comment") == 0)
228 for (i
= 0; attribute_names
[i
]; i
++)
229 if (strcmp (attribute_names
[i
], "xml:lang") == 0)
231 lang
= attribute_values
[i
];
235 parser
->current_lang_level
= language_level (lang
);
236 parser
->current_type
= MIME_TAG_TYPE_COMMENT
;
239 parser
->current_type
= MIME_TAG_TYPE_OTHER
;
243 mime_info_end_element (GMarkupParseContext
*context
,
244 const gchar
*element_name
,
248 MimeParser
*parser
= user_data
;
250 parser
->current_type
= MIME_TAG_TYPE_OTHER
;
254 mime_info_text (GMarkupParseContext
*context
,
260 MimeParser
*parser
= user_data
;
262 if (parser
->current_type
== MIME_TAG_TYPE_COMMENT
&&
263 parser
->current_lang_level
> parser
->comment_lang_level
)
265 g_free (parser
->comment
);
266 parser
->comment
= g_strndup (text
, text_len
);
267 parser
->comment_lang_level
= parser
->current_lang_level
;
272 load_comment_for_mime_helper (const char *dir
,
273 const char *basename
)
275 GMarkupParseContext
*context
;
276 char *filename
, *data
;
279 MimeParser parse_data
= {0};
280 GMarkupParser parser
= {
281 mime_info_start_element
,
282 mime_info_end_element
,
286 filename
= g_build_filename (dir
, "mime", basename
, NULL
);
288 res
= g_file_get_contents (filename
, &data
, &len
, NULL
);
293 context
= g_markup_parse_context_new (&parser
, 0, &parse_data
, NULL
);
294 res
= g_markup_parse_context_parse (context
, data
, len
, NULL
);
296 g_markup_parse_context_free (context
);
301 return parse_data
.comment
;
306 load_comment_for_mime (const char *mimetype
)
308 const char * const* dirs
;
313 basename
= g_strdup_printf ("%s.xml", mimetype
);
315 comment
= load_comment_for_mime_helper (g_get_user_data_dir (), basename
);
322 dirs
= g_get_system_data_dirs ();
324 for (i
= 0; dirs
[i
] != NULL
; i
++)
326 comment
= load_comment_for_mime_helper (dirs
[i
], basename
);
335 return g_strdup_printf (_("%s type"), mimetype
);
339 * g_content_type_get_description:
340 * @type: a content type string
342 * Gets the human readable description of the content type.
344 * Returns: a short description of the content type @type. Free the
345 * returned string with g_free()
348 g_content_type_get_description (const gchar
*type
)
350 static GHashTable
*type_comment_cache
= NULL
;
353 g_return_val_if_fail (type
!= NULL
, NULL
);
355 G_LOCK (gio_xdgmime
);
356 type
= xdg_mime_unalias_mime_type (type
);
358 if (type_comment_cache
== NULL
)
359 type_comment_cache
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, g_free
);
361 comment
= g_hash_table_lookup (type_comment_cache
, type
);
362 comment
= g_strdup (comment
);
363 G_UNLOCK (gio_xdgmime
);
368 comment
= load_comment_for_mime (type
);
370 G_LOCK (gio_xdgmime
);
371 g_hash_table_insert (type_comment_cache
,
374 G_UNLOCK (gio_xdgmime
);
380 * g_content_type_get_mime_type:
381 * @type: a content type string
383 * Gets the mime type for the content type, if one is registered.
385 * Returns: (allow-none): the registered mime type for the given @type,
386 * or %NULL if unknown.
389 g_content_type_get_mime_type (const char *type
)
391 g_return_val_if_fail (type
!= NULL
, NULL
);
393 return g_strdup (type
);
398 g_content_type_get_icon_internal (const gchar
*type
,
402 char *generic_mimetype_icon
= NULL
;
404 char *xdg_mimetype_icon
= NULL
;
405 char *legacy_mimetype_icon
;
406 char *xdg_mimetype_generic_icon
;
410 const char *file_template
;
411 const char *xdg_icon
;
413 g_return_val_if_fail (type
!= NULL
, NULL
);
417 file_template
= "%s-symbolic";
421 file_template
= "%s";
424 G_LOCK (gio_xdgmime
);
425 xdg_icon
= xdg_mime_get_icon (type
);
426 G_UNLOCK (gio_xdgmime
);
427 if (xdg_icon
!= NULL
)
428 xdg_mimetype_icon
= g_strdup_printf (file_template
, xdg_icon
);
429 xdg_mimetype_generic_icon
= g_content_type_get_generic_icon_name (type
);
431 mimetype_icon
= g_strdup_printf (file_template
, type
);
432 if (xdg_mimetype_generic_icon
)
433 generic_mimetype_icon
= g_strdup_printf (file_template
, xdg_mimetype_generic_icon
);
435 while ((q
= strchr (mimetype_icon
, '/')) != NULL
)
438 /* Not all icons have migrated to the new icon theme spec, look for old names too */
439 legacy_mimetype_icon
= g_strconcat ("gnome-mime-", mimetype_icon
, NULL
);
441 if (xdg_mimetype_icon
)
442 icon_names
[n
++] = xdg_mimetype_icon
;
444 icon_names
[n
++] = mimetype_icon
;
445 icon_names
[n
++] = legacy_mimetype_icon
;
447 if (generic_mimetype_icon
)
448 icon_names
[n
++] = generic_mimetype_icon
;
450 themed_icon
= g_themed_icon_new_from_names (icon_names
, n
);
452 g_free (xdg_mimetype_icon
);
453 g_free (xdg_mimetype_generic_icon
);
454 g_free (mimetype_icon
);
455 g_free (legacy_mimetype_icon
);
456 g_free (generic_mimetype_icon
);
462 * g_content_type_get_icon:
463 * @type: a content type string
465 * Gets the icon for a content type.
467 * Returns: (transfer full): #GIcon corresponding to the content type. Free the returned
468 * object with g_object_unref()
471 g_content_type_get_icon (const gchar
*type
)
473 return g_content_type_get_icon_internal (type
, FALSE
);
477 * g_content_type_get_symbolic_icon:
478 * @type: a content type string
480 * Gets the symbolic icon for a content type.
482 * Returns: (transfer full): symbolic #GIcon corresponding to the content type.
483 * Free the returned object with g_object_unref()
488 g_content_type_get_symbolic_icon (const gchar
*type
)
490 return g_content_type_get_icon_internal (type
, TRUE
);
494 * g_content_type_get_generic_icon_name:
495 * @type: a content type string
497 * Gets the generic icon name for a content type.
499 * See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
500 * specification for more on the generic icon name.
502 * Returns: (allow-none): the registered generic icon name for the given @type,
503 * or %NULL if unknown. Free with g_free()
508 g_content_type_get_generic_icon_name (const gchar
*type
)
510 const gchar
*xdg_icon_name
;
513 G_LOCK (gio_xdgmime
);
514 xdg_icon_name
= xdg_mime_get_generic_icon (type
);
515 G_UNLOCK (gio_xdgmime
);
520 const char *suffix
= "-x-generic";
522 p
= strchr (type
, '/');
524 p
= type
+ strlen (type
);
526 icon_name
= g_malloc (p
- type
+ strlen (suffix
) + 1);
527 memcpy (icon_name
, type
, p
- type
);
528 memcpy (icon_name
+ (p
- type
), suffix
, strlen (suffix
));
529 icon_name
[(p
- type
) + strlen (suffix
)] = 0;
533 icon_name
= g_strdup (xdg_icon_name
);
540 * g_content_type_can_be_executable:
541 * @type: a content type string
543 * Checks if a content type can be executable. Note that for instance
544 * things like text files can be executables (i.e. scripts and batch files).
546 * Returns: %TRUE if the file type corresponds to a type that
547 * can be executable, %FALSE otherwise.
550 g_content_type_can_be_executable (const gchar
*type
)
552 g_return_val_if_fail (type
!= NULL
, FALSE
);
554 if (g_content_type_is_a (type
, "application/x-executable") ||
555 g_content_type_is_a (type
, "text/plain"))
562 looks_like_text (const guchar
*data
, gsize data_size
)
567 for (i
= 0; i
< data_size
; i
++)
571 if (g_ascii_iscntrl (c
) &&
572 !g_ascii_isspace (c
) &&
580 * g_content_type_from_mime_type:
581 * @mime_type: a mime type string
583 * Tries to find a content type based on the mime type name.
585 * Returns: (allow-none): Newly allocated string with content type
586 * or %NULL. Free with g_free()
591 g_content_type_from_mime_type (const gchar
*mime_type
)
595 g_return_val_if_fail (mime_type
!= NULL
, NULL
);
597 G_LOCK (gio_xdgmime
);
598 /* mime type and content type are same on unixes */
599 umime
= g_strdup (xdg_mime_unalias_mime_type (mime_type
));
600 G_UNLOCK (gio_xdgmime
);
606 * g_content_type_guess:
607 * @filename: (allow-none): a string, or %NULL
608 * @data: (allow-none) (array length=data_size): a stream of data, or %NULL
609 * @data_size: the size of @data
610 * @result_uncertain: (allow-none) (out): return location for the certainty
611 * of the result, or %NULL
613 * Guesses the content type based on example data. If the function is
614 * uncertain, @result_uncertain will be set to %TRUE. Either @filename
615 * or @data may be %NULL, in which case the guess will be based solely
616 * on the other argument.
618 * Returns: a string indicating a guessed content type for the
619 * given data. Free with g_free()
622 g_content_type_guess (const gchar
*filename
,
625 gboolean
*result_uncertain
)
628 const char *name_mimetypes
[10], *sniffed_mimetype
;
631 int n_name_mimetypes
;
635 n_name_mimetypes
= 0;
636 sniffed_mimetype
= XDG_MIME_TYPE_UNKNOWN
;
638 if (result_uncertain
)
639 *result_uncertain
= FALSE
;
641 /* our test suite and potentially other code used -1 in the past, which is
642 * not documented and not allowed; guard against that */
643 g_return_val_if_fail (data_size
!= (gsize
) -1, g_strdup (XDG_MIME_TYPE_UNKNOWN
));
645 G_LOCK (gio_xdgmime
);
649 i
= strlen (filename
);
650 if (filename
[i
- 1] == '/')
652 name_mimetypes
[0] = "inode/directory";
653 name_mimetypes
[1] = NULL
;
654 n_name_mimetypes
= 1;
655 if (result_uncertain
)
656 *result_uncertain
= TRUE
;
660 basename
= g_path_get_basename (filename
);
661 n_name_mimetypes
= xdg_mime_get_mime_types_from_file_name (basename
, name_mimetypes
, 10);
666 /* Got an extension match, and no conflicts. This is it. */
667 if (n_name_mimetypes
== 1)
669 gchar
*s
= g_strdup (name_mimetypes
[0]);
670 G_UNLOCK (gio_xdgmime
);
676 sniffed_mimetype
= xdg_mime_get_mime_type_for_data (data
, data_size
, &sniffed_prio
);
677 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
679 looks_like_text (data
, data_size
))
680 sniffed_mimetype
= "text/plain";
682 /* For security reasons we don't ever want to sniff desktop files
683 * where we know the filename and it doesn't have a .desktop extension.
684 * This is because desktop files allow executing any application and
685 * we don't want to make it possible to hide them looking like something
688 if (filename
!= NULL
&&
689 strcmp (sniffed_mimetype
, "application/x-desktop") == 0)
690 sniffed_mimetype
= "text/plain";
693 if (n_name_mimetypes
== 0)
695 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
697 *result_uncertain
= TRUE
;
699 mimetype
= g_strdup (sniffed_mimetype
);
704 if (sniffed_mimetype
!= XDG_MIME_TYPE_UNKNOWN
)
706 if (sniffed_prio
>= 80) /* High priority sniffing match, use that */
707 mimetype
= g_strdup (sniffed_mimetype
);
710 /* There are conflicts between the name matches and we
711 * have a sniffed type, use that as a tie breaker.
713 for (i
= 0; i
< n_name_mimetypes
; i
++)
715 if ( xdg_mime_mime_type_subclass (name_mimetypes
[i
], sniffed_mimetype
))
717 /* This nametype match is derived from (or the same as)
718 * the sniffed type). This is probably it.
720 mimetype
= g_strdup (name_mimetypes
[i
]);
727 if (mimetype
== NULL
)
729 /* Conflicts, and sniffed type was no help or not there.
730 * Guess on the first one
732 mimetype
= g_strdup (name_mimetypes
[0]);
733 if (result_uncertain
)
734 *result_uncertain
= TRUE
;
738 G_UNLOCK (gio_xdgmime
);
744 enumerate_mimetypes_subdir (const char *dir
,
746 GHashTable
*mimetypes
)
755 while ((ent
= readdir (d
)) != NULL
)
757 if (g_str_has_suffix (ent
->d_name
, ".xml"))
759 mimetype
= g_strdup_printf ("%s/%.*s", prefix
, (int) strlen (ent
->d_name
) - 4, ent
->d_name
);
760 g_hash_table_replace (mimetypes
, mimetype
, NULL
);
768 enumerate_mimetypes_dir (const char *dir
,
769 GHashTable
*mimetypes
)
776 mimedir
= g_build_filename (dir
, "mime", NULL
);
778 d
= opendir (mimedir
);
781 while ((ent
= readdir (d
)) != NULL
)
783 if (strcmp (ent
->d_name
, "packages") != 0)
785 name
= g_build_filename (mimedir
, ent
->d_name
, NULL
);
786 if (g_file_test (name
, G_FILE_TEST_IS_DIR
))
787 enumerate_mimetypes_subdir (name
, ent
->d_name
, mimetypes
);
798 * g_content_types_get_registered:
800 * Gets a list of strings containing all the registered content types
801 * known to the system. The list and its data should be freed using
803 * g_list_free_full (list, g_free);
806 * Returns: (element-type utf8) (transfer full): #GList of the registered content types
809 g_content_types_get_registered (void)
811 const char * const* dirs
;
812 GHashTable
*mimetypes
;
818 mimetypes
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, NULL
);
820 enumerate_mimetypes_dir (g_get_user_data_dir (), mimetypes
);
821 dirs
= g_get_system_data_dirs ();
823 for (i
= 0; dirs
[i
] != NULL
; i
++)
824 enumerate_mimetypes_dir (dirs
[i
], mimetypes
);
827 g_hash_table_iter_init (&iter
, mimetypes
);
828 while (g_hash_table_iter_next (&iter
, &key
, NULL
))
830 l
= g_list_prepend (l
, key
);
831 g_hash_table_iter_steal (&iter
);
834 g_hash_table_destroy (mimetypes
);
840 /* tree magic data */
841 static GList
*tree_matches
= NULL
;
842 static gboolean need_reload
= FALSE
;
844 G_LOCK_DEFINE_STATIC (gio_treemagic
);
850 guint match_case
: 1;
851 guint executable
: 1;
867 tree_matchlet_free (TreeMatchlet
*matchlet
)
869 g_list_free_full (matchlet
->matches
, (GDestroyNotify
) tree_matchlet_free
);
870 g_free (matchlet
->path
);
871 g_free (matchlet
->mimetype
);
872 g_slice_free (TreeMatchlet
, matchlet
);
876 tree_match_free (TreeMatch
*match
)
878 g_list_free_full (match
->matches
, (GDestroyNotify
) tree_matchlet_free
);
879 g_free (match
->contenttype
);
880 g_slice_free (TreeMatch
, match
);
884 parse_header (gchar
*line
)
892 if (line
[0] != '[' || line
[len
- 1] != ']')
896 s
= strchr (line
, ':');
898 match
= g_slice_new0 (TreeMatch
);
899 match
->priority
= atoi (line
+ 1);
900 match
->contenttype
= g_strdup (s
+ 1);
905 static TreeMatchlet
*
906 parse_match_line (gchar
*line
,
910 TreeMatchlet
*matchlet
;
914 matchlet
= g_slice_new0 (TreeMatchlet
);
923 *depth
= atoi (line
);
924 s
= strchr (line
, '>');
930 matchlet
->path
= g_strdup (s
);
932 parts
= g_strsplit (s
, ",", 0);
933 if (strcmp (parts
[0], "=file") == 0)
934 matchlet
->type
= G_FILE_TYPE_REGULAR
;
935 else if (strcmp (parts
[0], "=directory") == 0)
936 matchlet
->type
= G_FILE_TYPE_DIRECTORY
;
937 else if (strcmp (parts
[0], "=link") == 0)
938 matchlet
->type
= G_FILE_TYPE_SYMBOLIC_LINK
;
940 matchlet
->type
= G_FILE_TYPE_UNKNOWN
;
941 for (i
= 1; parts
[i
]; i
++)
943 if (strcmp (parts
[i
], "executable") == 0)
944 matchlet
->executable
= 1;
945 else if (strcmp (parts
[i
], "match-case") == 0)
946 matchlet
->match_case
= 1;
947 else if (strcmp (parts
[i
], "non-empty") == 0)
948 matchlet
->non_empty
= 1;
949 else if (strcmp (parts
[i
], "on-disc") == 0)
950 matchlet
->on_disc
= 1;
952 matchlet
->mimetype
= g_strdup (parts
[i
]);
961 cmp_match (gconstpointer a
, gconstpointer b
)
963 const TreeMatch
*aa
= (const TreeMatch
*)a
;
964 const TreeMatch
*bb
= (const TreeMatch
*)b
;
966 return bb
->priority
- aa
->priority
;
970 insert_match (TreeMatch
*match
)
972 tree_matches
= g_list_insert_sorted (tree_matches
, match
, cmp_match
);
976 insert_matchlet (TreeMatch
*match
,
977 TreeMatchlet
*matchlet
,
981 match
->matches
= g_list_append (match
->matches
, matchlet
);
987 last
= g_list_last (match
->matches
);
990 tree_matchlet_free (matchlet
);
991 g_warning ("can't insert tree matchlet at depth %d", depth
);
995 m
= (TreeMatchlet
*) last
->data
;
998 last
= g_list_last (m
->matches
);
1001 tree_matchlet_free (matchlet
);
1002 g_warning ("can't insert tree matchlet at depth %d", depth
);
1006 m
= (TreeMatchlet
*) last
->data
;
1008 m
->matches
= g_list_append (m
->matches
, matchlet
);
1013 read_tree_magic_from_directory (const gchar
*prefix
)
1021 TreeMatchlet
*matchlet
;
1024 filename
= g_build_filename (prefix
, "mime", "treemagic", NULL
);
1026 if (g_file_get_contents (filename
, &text
, &len
, NULL
))
1028 if (strcmp (text
, "MIME-TreeMagic") == 0)
1030 lines
= g_strsplit (text
+ strlen ("MIME-TreeMagic") + 2, "\n", 0);
1032 for (i
= 0; lines
[i
] && lines
[i
][0]; i
++)
1034 if (lines
[i
][0] == '[')
1036 match
= parse_header (lines
[i
]);
1037 insert_match (match
);
1041 matchlet
= parse_match_line (lines
[i
], &depth
);
1042 insert_matchlet (match
, matchlet
, depth
);
1049 g_warning ("%s: header not found, skipping\n", filename
);
1059 xdg_mime_reload (void *user_data
)
1065 tree_magic_shutdown (void)
1067 g_list_free_full (tree_matches
, (GDestroyNotify
) tree_match_free
);
1068 tree_matches
= NULL
;
1072 tree_magic_init (void)
1074 static gboolean initialized
= FALSE
;
1076 const gchar
* const * dirs
;
1083 xdg_mime_register_reload_callback (xdg_mime_reload
, NULL
, NULL
);
1089 need_reload
= FALSE
;
1091 tree_magic_shutdown ();
1093 dir
= g_get_user_data_dir ();
1094 read_tree_magic_from_directory (dir
);
1095 dirs
= g_get_system_data_dirs ();
1096 for (i
= 0; dirs
[i
]; i
++)
1097 read_tree_magic_from_directory (dirs
[i
]);
1101 /* a filtering enumerator */
1107 gboolean ignore_case
;
1109 gchar
**case_components
;
1110 GFileEnumerator
**enumerators
;
1115 component_match (Enumerator
*e
,
1119 gchar
*case_folded
, *key
;
1122 if (strcmp (name
, e
->components
[depth
]) == 0)
1125 if (!e
->ignore_case
)
1128 case_folded
= g_utf8_casefold (name
, -1);
1129 key
= g_utf8_collate_key (case_folded
, -1);
1131 found
= strcmp (key
, e
->case_components
[depth
]) == 0;
1133 g_free (case_folded
);
1140 next_match_recurse (Enumerator
*e
,
1149 if (e
->enumerators
[depth
] == NULL
)
1153 file
= next_match_recurse (e
, depth
- 1);
1156 e
->children
[depth
] = file
;
1157 e
->enumerators
[depth
] = g_file_enumerate_children (file
,
1158 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1159 G_FILE_QUERY_INFO_NONE
,
1164 if (e
->enumerators
[depth
] == NULL
)
1168 while ((info
= g_file_enumerator_next_file (e
->enumerators
[depth
], NULL
, NULL
)))
1170 name
= g_file_info_get_name (info
);
1171 if (component_match (e
, depth
, name
))
1173 file
= g_file_get_child (e
->children
[depth
], name
);
1174 g_object_unref (info
);
1177 g_object_unref (info
);
1180 g_object_unref (e
->enumerators
[depth
]);
1181 e
->enumerators
[depth
] = NULL
;
1182 g_object_unref (e
->children
[depth
]);
1183 e
->children
[depth
] = NULL
;
1188 enumerator_next (Enumerator
*e
)
1190 return next_match_recurse (e
, e
->depth
- 1);
1194 enumerator_new (GFile
*root
,
1196 gboolean ignore_case
)
1202 e
= g_new0 (Enumerator
, 1);
1203 e
->path
= g_strdup (path
);
1204 e
->ignore_case
= ignore_case
;
1206 e
->components
= g_strsplit (e
->path
, G_DIR_SEPARATOR_S
, -1);
1207 e
->depth
= g_strv_length (e
->components
);
1210 e
->case_components
= g_new0 (char *, e
->depth
+ 1);
1211 for (i
= 0; e
->components
[i
]; i
++)
1213 case_folded
= g_utf8_casefold (e
->components
[i
], -1);
1214 e
->case_components
[i
] = g_utf8_collate_key (case_folded
, -1);
1215 g_free (case_folded
);
1219 e
->children
= g_new0 (GFile
*, e
->depth
);
1220 e
->children
[0] = g_object_ref (root
);
1221 e
->enumerators
= g_new0 (GFileEnumerator
*, e
->depth
);
1222 e
->enumerators
[0] = g_file_enumerate_children (root
,
1223 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1224 G_FILE_QUERY_INFO_NONE
,
1232 enumerator_free (Enumerator
*e
)
1236 for (i
= 0; i
< e
->depth
; i
++)
1238 if (e
->enumerators
[i
])
1239 g_object_unref (e
->enumerators
[i
]);
1241 g_object_unref (e
->children
[i
]);
1244 g_free (e
->enumerators
);
1245 g_free (e
->children
);
1246 g_strfreev (e
->components
);
1247 if (e
->case_components
)
1248 g_strfreev (e
->case_components
);
1254 matchlet_match (TreeMatchlet
*matchlet
,
1264 e
= enumerator_new (root
, matchlet
->path
, !matchlet
->match_case
);
1268 file
= enumerator_next (e
);
1271 enumerator_free (e
);
1275 if (matchlet
->mimetype
)
1276 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1277 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
","
1278 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
;
1280 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1281 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
;
1282 info
= g_file_query_info (file
,
1284 G_FILE_QUERY_INFO_NONE
,
1291 if (matchlet
->type
!= G_FILE_TYPE_UNKNOWN
&&
1292 g_file_info_get_file_type (info
) != matchlet
->type
)
1295 if (matchlet
->executable
&&
1296 !g_file_info_get_attribute_boolean (info
, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
))
1302 if (result
&& matchlet
->non_empty
)
1304 GFileEnumerator
*child_enum
;
1305 GFileInfo
*child_info
;
1307 child_enum
= g_file_enumerate_children (file
,
1308 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1309 G_FILE_QUERY_INFO_NONE
,
1315 child_info
= g_file_enumerator_next_file (child_enum
, NULL
, NULL
);
1317 g_object_unref (child_info
);
1320 g_object_unref (child_enum
);
1326 if (result
&& matchlet
->mimetype
)
1328 if (strcmp (matchlet
->mimetype
, g_file_info_get_content_type (info
)) != 0)
1332 g_object_unref (info
);
1333 g_object_unref (file
);
1337 enumerator_free (e
);
1339 if (!matchlet
->matches
)
1342 for (l
= matchlet
->matches
; l
; l
= l
->next
)
1344 TreeMatchlet
*submatchlet
;
1346 submatchlet
= l
->data
;
1347 if (matchlet_match (submatchlet
, root
))
1355 match_match (TreeMatch
*match
,
1361 for (l
= match
->matches
; l
; l
= l
->next
)
1363 TreeMatchlet
*matchlet
= l
->data
;
1364 if (matchlet_match (matchlet
, root
))
1366 g_ptr_array_add (types
, g_strdup (match
->contenttype
));
1373 * g_content_type_guess_for_tree:
1374 * @root: the root of the tree to guess a type for
1376 * Tries to guess the type of the tree with root @root, by
1377 * looking at the files it contains. The result is an array
1378 * of content types, with the best guess coming first.
1380 * The types returned all have the form x-content/foo, e.g.
1381 * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
1382 * (for a camera memory card). See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
1383 * specification for more on x-content types.
1385 * This function is useful in the implementation of
1386 * g_mount_guess_content_type().
1388 * Returns: (transfer full) (array zero-terminated=1): an %NULL-terminated
1389 * array of zero or more content types. Free with g_strfreev()
1394 g_content_type_guess_for_tree (GFile
*root
)
1399 types
= g_ptr_array_new ();
1401 G_LOCK (gio_treemagic
);
1404 for (l
= tree_matches
; l
; l
= l
->next
)
1406 TreeMatch
*match
= l
->data
;
1407 match_match (match
, root
, types
);
1410 G_UNLOCK (gio_treemagic
);
1412 g_ptr_array_add (types
, NULL
);
1414 return (gchar
**)g_ptr_array_free (types
, FALSE
);