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
);
396 #pragma GCC diagnostic push
397 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
400 g_content_type_get_icon_internal (const gchar
*type
,
404 char *generic_mimetype_icon
= NULL
;
406 char *xdg_mimetype_icon
= NULL
;
407 char *xdg_mimetype_generic_icon
;
411 const char *file_template
;
412 const char *xdg_icon
;
414 g_return_val_if_fail (type
!= NULL
, NULL
);
418 file_template
= "%s-symbolic";
422 file_template
= "%s";
425 G_LOCK (gio_xdgmime
);
426 xdg_icon
= xdg_mime_get_icon (type
);
427 G_UNLOCK (gio_xdgmime
);
428 if (xdg_icon
!= NULL
)
429 xdg_mimetype_icon
= g_strdup_printf (file_template
, xdg_icon
);
431 if (xdg_mimetype_icon
)
432 icon_names
[n
++] = xdg_mimetype_icon
;
434 mimetype_icon
= g_strdup_printf (file_template
, type
);
435 while ((q
= strchr (mimetype_icon
, '/')) != NULL
)
438 icon_names
[n
++] = mimetype_icon
;
440 xdg_mimetype_generic_icon
= g_content_type_get_generic_icon_name (type
);
441 if (xdg_mimetype_generic_icon
)
442 generic_mimetype_icon
= g_strdup_printf (file_template
, xdg_mimetype_generic_icon
);
443 if (generic_mimetype_icon
)
444 icon_names
[n
++] = generic_mimetype_icon
;
446 themed_icon
= g_themed_icon_new_from_names (icon_names
, n
);
448 g_free (xdg_mimetype_icon
);
449 g_free (xdg_mimetype_generic_icon
);
450 g_free (mimetype_icon
);
451 g_free (generic_mimetype_icon
);
455 #pragma GCC diagnostic pop
458 * g_content_type_get_icon:
459 * @type: a content type string
461 * Gets the icon for a content type.
463 * Returns: (transfer full): #GIcon corresponding to the content type. Free the returned
464 * object with g_object_unref()
467 g_content_type_get_icon (const gchar
*type
)
469 return g_content_type_get_icon_internal (type
, FALSE
);
473 * g_content_type_get_symbolic_icon:
474 * @type: a content type string
476 * Gets the symbolic icon for a content type.
478 * Returns: (transfer full): symbolic #GIcon corresponding to the content type.
479 * Free the returned object with g_object_unref()
484 g_content_type_get_symbolic_icon (const gchar
*type
)
486 return g_content_type_get_icon_internal (type
, TRUE
);
490 * g_content_type_get_generic_icon_name:
491 * @type: a content type string
493 * Gets the generic icon name for a content type.
495 * See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
496 * specification for more on the generic icon name.
498 * Returns: (allow-none): the registered generic icon name for the given @type,
499 * or %NULL if unknown. Free with g_free()
504 g_content_type_get_generic_icon_name (const gchar
*type
)
506 const gchar
*xdg_icon_name
;
509 G_LOCK (gio_xdgmime
);
510 xdg_icon_name
= xdg_mime_get_generic_icon (type
);
511 G_UNLOCK (gio_xdgmime
);
516 const char *suffix
= "-x-generic";
518 p
= strchr (type
, '/');
520 p
= type
+ strlen (type
);
522 icon_name
= g_malloc (p
- type
+ strlen (suffix
) + 1);
523 memcpy (icon_name
, type
, p
- type
);
524 memcpy (icon_name
+ (p
- type
), suffix
, strlen (suffix
));
525 icon_name
[(p
- type
) + strlen (suffix
)] = 0;
529 icon_name
= g_strdup (xdg_icon_name
);
536 * g_content_type_can_be_executable:
537 * @type: a content type string
539 * Checks if a content type can be executable. Note that for instance
540 * things like text files can be executables (i.e. scripts and batch files).
542 * Returns: %TRUE if the file type corresponds to a type that
543 * can be executable, %FALSE otherwise.
546 g_content_type_can_be_executable (const gchar
*type
)
548 g_return_val_if_fail (type
!= NULL
, FALSE
);
550 if (g_content_type_is_a (type
, "application/x-executable") ||
551 g_content_type_is_a (type
, "text/plain"))
558 looks_like_text (const guchar
*data
, gsize data_size
)
563 for (i
= 0; i
< data_size
; i
++)
567 if (g_ascii_iscntrl (c
) &&
568 !g_ascii_isspace (c
) &&
576 * g_content_type_from_mime_type:
577 * @mime_type: a mime type string
579 * Tries to find a content type based on the mime type name.
581 * Returns: (allow-none): Newly allocated string with content type
582 * or %NULL. Free with g_free()
587 g_content_type_from_mime_type (const gchar
*mime_type
)
591 g_return_val_if_fail (mime_type
!= NULL
, NULL
);
593 G_LOCK (gio_xdgmime
);
594 /* mime type and content type are same on unixes */
595 umime
= g_strdup (xdg_mime_unalias_mime_type (mime_type
));
596 G_UNLOCK (gio_xdgmime
);
602 * g_content_type_guess:
603 * @filename: (allow-none): a string, or %NULL
604 * @data: (allow-none) (array length=data_size): a stream of data, or %NULL
605 * @data_size: the size of @data
606 * @result_uncertain: (allow-none) (out): return location for the certainty
607 * of the result, or %NULL
609 * Guesses the content type based on example data. If the function is
610 * uncertain, @result_uncertain will be set to %TRUE. Either @filename
611 * or @data may be %NULL, in which case the guess will be based solely
612 * on the other argument.
614 * Returns: a string indicating a guessed content type for the
615 * given data. Free with g_free()
618 g_content_type_guess (const gchar
*filename
,
621 gboolean
*result_uncertain
)
624 const char *name_mimetypes
[10], *sniffed_mimetype
;
627 int n_name_mimetypes
;
631 n_name_mimetypes
= 0;
632 sniffed_mimetype
= XDG_MIME_TYPE_UNKNOWN
;
634 if (result_uncertain
)
635 *result_uncertain
= FALSE
;
637 /* our test suite and potentially other code used -1 in the past, which is
638 * not documented and not allowed; guard against that */
639 g_return_val_if_fail (data_size
!= (gsize
) -1, g_strdup (XDG_MIME_TYPE_UNKNOWN
));
641 G_LOCK (gio_xdgmime
);
645 i
= strlen (filename
);
646 if (filename
[i
- 1] == '/')
648 name_mimetypes
[0] = "inode/directory";
649 name_mimetypes
[1] = NULL
;
650 n_name_mimetypes
= 1;
651 if (result_uncertain
)
652 *result_uncertain
= TRUE
;
656 basename
= g_path_get_basename (filename
);
657 n_name_mimetypes
= xdg_mime_get_mime_types_from_file_name (basename
, name_mimetypes
, 10);
662 /* Got an extension match, and no conflicts. This is it. */
663 if (n_name_mimetypes
== 1)
665 gchar
*s
= g_strdup (name_mimetypes
[0]);
666 G_UNLOCK (gio_xdgmime
);
672 sniffed_mimetype
= xdg_mime_get_mime_type_for_data (data
, data_size
, &sniffed_prio
);
673 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
675 looks_like_text (data
, data_size
))
676 sniffed_mimetype
= "text/plain";
678 /* For security reasons we don't ever want to sniff desktop files
679 * where we know the filename and it doesn't have a .desktop extension.
680 * This is because desktop files allow executing any application and
681 * we don't want to make it possible to hide them looking like something
684 if (filename
!= NULL
&&
685 strcmp (sniffed_mimetype
, "application/x-desktop") == 0)
686 sniffed_mimetype
= "text/plain";
689 if (n_name_mimetypes
== 0)
691 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
693 *result_uncertain
= TRUE
;
695 mimetype
= g_strdup (sniffed_mimetype
);
700 if (sniffed_mimetype
!= XDG_MIME_TYPE_UNKNOWN
)
702 if (sniffed_prio
>= 80) /* High priority sniffing match, use that */
703 mimetype
= g_strdup (sniffed_mimetype
);
706 /* There are conflicts between the name matches and we
707 * have a sniffed type, use that as a tie breaker.
709 for (i
= 0; i
< n_name_mimetypes
; i
++)
711 if ( xdg_mime_mime_type_subclass (name_mimetypes
[i
], sniffed_mimetype
))
713 /* This nametype match is derived from (or the same as)
714 * the sniffed type). This is probably it.
716 mimetype
= g_strdup (name_mimetypes
[i
]);
723 if (mimetype
== NULL
)
725 /* Conflicts, and sniffed type was no help or not there.
726 * Guess on the first one
728 mimetype
= g_strdup (name_mimetypes
[0]);
729 if (result_uncertain
)
730 *result_uncertain
= TRUE
;
734 G_UNLOCK (gio_xdgmime
);
740 enumerate_mimetypes_subdir (const char *dir
,
742 GHashTable
*mimetypes
)
751 while ((ent
= readdir (d
)) != NULL
)
753 if (g_str_has_suffix (ent
->d_name
, ".xml"))
755 mimetype
= g_strdup_printf ("%s/%.*s", prefix
, (int) strlen (ent
->d_name
) - 4, ent
->d_name
);
756 g_hash_table_replace (mimetypes
, mimetype
, NULL
);
764 enumerate_mimetypes_dir (const char *dir
,
765 GHashTable
*mimetypes
)
772 mimedir
= g_build_filename (dir
, "mime", NULL
);
774 d
= opendir (mimedir
);
777 while ((ent
= readdir (d
)) != NULL
)
779 if (strcmp (ent
->d_name
, "packages") != 0)
781 name
= g_build_filename (mimedir
, ent
->d_name
, NULL
);
782 if (g_file_test (name
, G_FILE_TEST_IS_DIR
))
783 enumerate_mimetypes_subdir (name
, ent
->d_name
, mimetypes
);
794 * g_content_types_get_registered:
796 * Gets a list of strings containing all the registered content types
797 * known to the system. The list and its data should be freed using
799 * g_list_free_full (list, g_free);
802 * Returns: (element-type utf8) (transfer full): #GList of the registered content types
805 g_content_types_get_registered (void)
807 const char * const* dirs
;
808 GHashTable
*mimetypes
;
814 mimetypes
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, NULL
);
816 enumerate_mimetypes_dir (g_get_user_data_dir (), mimetypes
);
817 dirs
= g_get_system_data_dirs ();
819 for (i
= 0; dirs
[i
] != NULL
; i
++)
820 enumerate_mimetypes_dir (dirs
[i
], mimetypes
);
823 g_hash_table_iter_init (&iter
, mimetypes
);
824 while (g_hash_table_iter_next (&iter
, &key
, NULL
))
826 l
= g_list_prepend (l
, key
);
827 g_hash_table_iter_steal (&iter
);
830 g_hash_table_destroy (mimetypes
);
836 /* tree magic data */
837 static GList
*tree_matches
= NULL
;
838 static gboolean need_reload
= FALSE
;
840 G_LOCK_DEFINE_STATIC (gio_treemagic
);
846 guint match_case
: 1;
847 guint executable
: 1;
863 tree_matchlet_free (TreeMatchlet
*matchlet
)
865 g_list_free_full (matchlet
->matches
, (GDestroyNotify
) tree_matchlet_free
);
866 g_free (matchlet
->path
);
867 g_free (matchlet
->mimetype
);
868 g_slice_free (TreeMatchlet
, matchlet
);
872 tree_match_free (TreeMatch
*match
)
874 g_list_free_full (match
->matches
, (GDestroyNotify
) tree_matchlet_free
);
875 g_free (match
->contenttype
);
876 g_slice_free (TreeMatch
, match
);
880 parse_header (gchar
*line
)
888 if (line
[0] != '[' || line
[len
- 1] != ']')
892 s
= strchr (line
, ':');
894 match
= g_slice_new0 (TreeMatch
);
895 match
->priority
= atoi (line
+ 1);
896 match
->contenttype
= g_strdup (s
+ 1);
901 static TreeMatchlet
*
902 parse_match_line (gchar
*line
,
906 TreeMatchlet
*matchlet
;
910 matchlet
= g_slice_new0 (TreeMatchlet
);
919 *depth
= atoi (line
);
920 s
= strchr (line
, '>');
926 matchlet
->path
= g_strdup (s
);
928 parts
= g_strsplit (s
, ",", 0);
929 if (strcmp (parts
[0], "=file") == 0)
930 matchlet
->type
= G_FILE_TYPE_REGULAR
;
931 else if (strcmp (parts
[0], "=directory") == 0)
932 matchlet
->type
= G_FILE_TYPE_DIRECTORY
;
933 else if (strcmp (parts
[0], "=link") == 0)
934 matchlet
->type
= G_FILE_TYPE_SYMBOLIC_LINK
;
936 matchlet
->type
= G_FILE_TYPE_UNKNOWN
;
937 for (i
= 1; parts
[i
]; i
++)
939 if (strcmp (parts
[i
], "executable") == 0)
940 matchlet
->executable
= 1;
941 else if (strcmp (parts
[i
], "match-case") == 0)
942 matchlet
->match_case
= 1;
943 else if (strcmp (parts
[i
], "non-empty") == 0)
944 matchlet
->non_empty
= 1;
945 else if (strcmp (parts
[i
], "on-disc") == 0)
946 matchlet
->on_disc
= 1;
948 matchlet
->mimetype
= g_strdup (parts
[i
]);
957 cmp_match (gconstpointer a
, gconstpointer b
)
959 const TreeMatch
*aa
= (const TreeMatch
*)a
;
960 const TreeMatch
*bb
= (const TreeMatch
*)b
;
962 return bb
->priority
- aa
->priority
;
966 insert_match (TreeMatch
*match
)
968 tree_matches
= g_list_insert_sorted (tree_matches
, match
, cmp_match
);
972 insert_matchlet (TreeMatch
*match
,
973 TreeMatchlet
*matchlet
,
977 match
->matches
= g_list_append (match
->matches
, matchlet
);
983 last
= g_list_last (match
->matches
);
986 tree_matchlet_free (matchlet
);
987 g_warning ("can't insert tree matchlet at depth %d", depth
);
991 m
= (TreeMatchlet
*) last
->data
;
994 last
= g_list_last (m
->matches
);
997 tree_matchlet_free (matchlet
);
998 g_warning ("can't insert tree matchlet at depth %d", depth
);
1002 m
= (TreeMatchlet
*) last
->data
;
1004 m
->matches
= g_list_append (m
->matches
, matchlet
);
1009 read_tree_magic_from_directory (const gchar
*prefix
)
1017 TreeMatchlet
*matchlet
;
1020 filename
= g_build_filename (prefix
, "mime", "treemagic", NULL
);
1022 if (g_file_get_contents (filename
, &text
, &len
, NULL
))
1024 if (strcmp (text
, "MIME-TreeMagic") == 0)
1026 lines
= g_strsplit (text
+ strlen ("MIME-TreeMagic") + 2, "\n", 0);
1028 for (i
= 0; lines
[i
] && lines
[i
][0]; i
++)
1030 if (lines
[i
][0] == '[')
1032 match
= parse_header (lines
[i
]);
1033 insert_match (match
);
1037 matchlet
= parse_match_line (lines
[i
], &depth
);
1038 insert_matchlet (match
, matchlet
, depth
);
1045 g_warning ("%s: header not found, skipping\n", filename
);
1055 xdg_mime_reload (void *user_data
)
1061 tree_magic_shutdown (void)
1063 g_list_free_full (tree_matches
, (GDestroyNotify
) tree_match_free
);
1064 tree_matches
= NULL
;
1068 tree_magic_init (void)
1070 static gboolean initialized
= FALSE
;
1072 const gchar
* const * dirs
;
1079 xdg_mime_register_reload_callback (xdg_mime_reload
, NULL
, NULL
);
1085 need_reload
= FALSE
;
1087 tree_magic_shutdown ();
1089 dir
= g_get_user_data_dir ();
1090 read_tree_magic_from_directory (dir
);
1091 dirs
= g_get_system_data_dirs ();
1092 for (i
= 0; dirs
[i
]; i
++)
1093 read_tree_magic_from_directory (dirs
[i
]);
1097 /* a filtering enumerator */
1103 gboolean ignore_case
;
1105 gchar
**case_components
;
1106 GFileEnumerator
**enumerators
;
1111 component_match (Enumerator
*e
,
1115 gchar
*case_folded
, *key
;
1118 if (strcmp (name
, e
->components
[depth
]) == 0)
1121 if (!e
->ignore_case
)
1124 case_folded
= g_utf8_casefold (name
, -1);
1125 key
= g_utf8_collate_key (case_folded
, -1);
1127 found
= strcmp (key
, e
->case_components
[depth
]) == 0;
1129 g_free (case_folded
);
1136 next_match_recurse (Enumerator
*e
,
1145 if (e
->enumerators
[depth
] == NULL
)
1149 file
= next_match_recurse (e
, depth
- 1);
1152 e
->children
[depth
] = file
;
1153 e
->enumerators
[depth
] = g_file_enumerate_children (file
,
1154 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1155 G_FILE_QUERY_INFO_NONE
,
1160 if (e
->enumerators
[depth
] == NULL
)
1164 while ((info
= g_file_enumerator_next_file (e
->enumerators
[depth
], NULL
, NULL
)))
1166 name
= g_file_info_get_name (info
);
1167 if (component_match (e
, depth
, name
))
1169 file
= g_file_get_child (e
->children
[depth
], name
);
1170 g_object_unref (info
);
1173 g_object_unref (info
);
1176 g_object_unref (e
->enumerators
[depth
]);
1177 e
->enumerators
[depth
] = NULL
;
1178 g_object_unref (e
->children
[depth
]);
1179 e
->children
[depth
] = NULL
;
1184 enumerator_next (Enumerator
*e
)
1186 return next_match_recurse (e
, e
->depth
- 1);
1190 enumerator_new (GFile
*root
,
1192 gboolean ignore_case
)
1198 e
= g_new0 (Enumerator
, 1);
1199 e
->path
= g_strdup (path
);
1200 e
->ignore_case
= ignore_case
;
1202 e
->components
= g_strsplit (e
->path
, G_DIR_SEPARATOR_S
, -1);
1203 e
->depth
= g_strv_length (e
->components
);
1206 e
->case_components
= g_new0 (char *, e
->depth
+ 1);
1207 for (i
= 0; e
->components
[i
]; i
++)
1209 case_folded
= g_utf8_casefold (e
->components
[i
], -1);
1210 e
->case_components
[i
] = g_utf8_collate_key (case_folded
, -1);
1211 g_free (case_folded
);
1215 e
->children
= g_new0 (GFile
*, e
->depth
);
1216 e
->children
[0] = g_object_ref (root
);
1217 e
->enumerators
= g_new0 (GFileEnumerator
*, e
->depth
);
1218 e
->enumerators
[0] = g_file_enumerate_children (root
,
1219 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1220 G_FILE_QUERY_INFO_NONE
,
1228 enumerator_free (Enumerator
*e
)
1232 for (i
= 0; i
< e
->depth
; i
++)
1234 if (e
->enumerators
[i
])
1235 g_object_unref (e
->enumerators
[i
]);
1237 g_object_unref (e
->children
[i
]);
1240 g_free (e
->enumerators
);
1241 g_free (e
->children
);
1242 g_strfreev (e
->components
);
1243 if (e
->case_components
)
1244 g_strfreev (e
->case_components
);
1250 matchlet_match (TreeMatchlet
*matchlet
,
1260 e
= enumerator_new (root
, matchlet
->path
, !matchlet
->match_case
);
1264 file
= enumerator_next (e
);
1267 enumerator_free (e
);
1271 if (matchlet
->mimetype
)
1272 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1273 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
","
1274 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
;
1276 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1277 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
;
1278 info
= g_file_query_info (file
,
1280 G_FILE_QUERY_INFO_NONE
,
1287 if (matchlet
->type
!= G_FILE_TYPE_UNKNOWN
&&
1288 g_file_info_get_file_type (info
) != matchlet
->type
)
1291 if (matchlet
->executable
&&
1292 !g_file_info_get_attribute_boolean (info
, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
))
1298 if (result
&& matchlet
->non_empty
)
1300 GFileEnumerator
*child_enum
;
1301 GFileInfo
*child_info
;
1303 child_enum
= g_file_enumerate_children (file
,
1304 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1305 G_FILE_QUERY_INFO_NONE
,
1311 child_info
= g_file_enumerator_next_file (child_enum
, NULL
, NULL
);
1313 g_object_unref (child_info
);
1316 g_object_unref (child_enum
);
1322 if (result
&& matchlet
->mimetype
)
1324 if (strcmp (matchlet
->mimetype
, g_file_info_get_content_type (info
)) != 0)
1328 g_object_unref (info
);
1329 g_object_unref (file
);
1333 enumerator_free (e
);
1335 if (!matchlet
->matches
)
1338 for (l
= matchlet
->matches
; l
; l
= l
->next
)
1340 TreeMatchlet
*submatchlet
;
1342 submatchlet
= l
->data
;
1343 if (matchlet_match (submatchlet
, root
))
1351 match_match (TreeMatch
*match
,
1357 for (l
= match
->matches
; l
; l
= l
->next
)
1359 TreeMatchlet
*matchlet
= l
->data
;
1360 if (matchlet_match (matchlet
, root
))
1362 g_ptr_array_add (types
, g_strdup (match
->contenttype
));
1369 * g_content_type_guess_for_tree:
1370 * @root: the root of the tree to guess a type for
1372 * Tries to guess the type of the tree with root @root, by
1373 * looking at the files it contains. The result is an array
1374 * of content types, with the best guess coming first.
1376 * The types returned all have the form x-content/foo, e.g.
1377 * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
1378 * (for a camera memory card). See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
1379 * specification for more on x-content types.
1381 * This function is useful in the implementation of
1382 * g_mount_guess_content_type().
1384 * Returns: (transfer full) (array zero-terminated=1): an %NULL-terminated
1385 * array of zero or more content types. Free with g_strfreev()
1390 g_content_type_guess_for_tree (GFile
*root
)
1395 types
= g_ptr_array_new ();
1397 G_LOCK (gio_treemagic
);
1400 for (l
= tree_matches
; l
; l
= l
->next
)
1402 TreeMatch
*match
= l
->data
;
1403 match_match (match
, root
, types
);
1406 G_UNLOCK (gio_treemagic
);
1408 g_ptr_array_add (types
, NULL
);
1410 return (gchar
**)g_ptr_array_free (types
, FALSE
);