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
;
404 char *xdg_mimetype_icon
;
405 char *legacy_mimetype_icon
;
406 char *xdg_mimetype_generic_icon
;
411 const char *file_template
;
412 const char *generic_suffix
;
414 g_return_val_if_fail (type
!= NULL
, NULL
);
418 file_template
= "%s-symbolic";
419 generic_suffix
= "-x-generic-symbolic";
423 file_template
= "%s";
424 generic_suffix
= "-x-generic";
427 G_LOCK (gio_xdgmime
);
428 xdg_mimetype_icon
= g_strdup_printf (file_template
, xdg_mime_get_icon (type
));
429 xdg_mimetype_generic_icon
= g_strdup_printf (file_template
, xdg_mime_get_generic_icon (type
));
430 G_UNLOCK (gio_xdgmime
);
432 mimetype_icon
= g_strdup_printf (file_template
, type
);
434 while ((q
= strchr (mimetype_icon
, '/')) != NULL
)
437 p
= strchr (type
, '/');
439 p
= type
+ strlen (type
);
441 /* Not all icons have migrated to the new icon theme spec, look for old names too */
442 legacy_mimetype_icon
= g_strconcat ("gnome-mime-", mimetype_icon
, NULL
);
444 generic_mimetype_icon
= g_malloc (p
- type
+ strlen (generic_suffix
) + 1);
445 memcpy (generic_mimetype_icon
, type
, p
- type
);
446 memcpy (generic_mimetype_icon
+ (p
- type
), generic_suffix
, strlen (generic_suffix
));
447 generic_mimetype_icon
[(p
- type
) + strlen (generic_suffix
)] = 0;
449 if (xdg_mimetype_icon
)
450 icon_names
[n
++] = xdg_mimetype_icon
;
452 icon_names
[n
++] = mimetype_icon
;
453 icon_names
[n
++] = legacy_mimetype_icon
;
455 if (xdg_mimetype_generic_icon
)
456 icon_names
[n
++] = xdg_mimetype_generic_icon
;
458 icon_names
[n
++] = generic_mimetype_icon
;
460 themed_icon
= g_themed_icon_new_from_names (icon_names
, n
);
462 g_free (xdg_mimetype_icon
);
463 g_free (xdg_mimetype_generic_icon
);
464 g_free (mimetype_icon
);
465 g_free (legacy_mimetype_icon
);
466 g_free (generic_mimetype_icon
);
472 * g_content_type_get_icon:
473 * @type: a content type string
475 * Gets the icon for a content type.
477 * Returns: (transfer full): #GIcon corresponding to the content type. Free the returned
478 * object with g_object_unref()
481 g_content_type_get_icon (const gchar
*type
)
483 return g_content_type_get_icon_internal (type
, FALSE
);
487 * g_content_type_get_symbolic_icon:
488 * @type: a content type string
490 * Gets the symbolic icon for a content type.
492 * Returns: (transfer full): symbolic #GIcon corresponding to the content type.
493 * Free the returned object with g_object_unref()
498 g_content_type_get_symbolic_icon (const gchar
*type
)
500 return g_content_type_get_icon_internal (type
, TRUE
);
504 * g_content_type_can_be_executable:
505 * @type: a content type string
507 * Checks if a content type can be executable. Note that for instance
508 * things like text files can be executables (i.e. scripts and batch files).
510 * Returns: %TRUE if the file type corresponds to a type that
511 * can be executable, %FALSE otherwise.
514 g_content_type_can_be_executable (const gchar
*type
)
516 g_return_val_if_fail (type
!= NULL
, FALSE
);
518 if (g_content_type_is_a (type
, "application/x-executable") ||
519 g_content_type_is_a (type
, "text/plain"))
526 looks_like_text (const guchar
*data
, gsize data_size
)
531 for (i
= 0; i
< data_size
; i
++)
535 if (g_ascii_iscntrl (c
) &&
536 !g_ascii_isspace (c
) &&
544 * g_content_type_from_mime_type:
545 * @mime_type: a mime type string
547 * Tries to find a content type based on the mime type name.
549 * Returns: (allow-none): Newly allocated string with content type
550 * or %NULL. Free with g_free()
555 g_content_type_from_mime_type (const gchar
*mime_type
)
559 g_return_val_if_fail (mime_type
!= NULL
, NULL
);
561 G_LOCK (gio_xdgmime
);
562 /* mime type and content type are same on unixes */
563 umime
= g_strdup (xdg_mime_unalias_mime_type (mime_type
));
564 G_UNLOCK (gio_xdgmime
);
570 * g_content_type_guess:
571 * @filename: (allow-none): a string, or %NULL
572 * @data: (allow-none) (array length=data_size): a stream of data, or %NULL
573 * @data_size: the size of @data
574 * @result_uncertain: (allow-none) (out): return location for the certainty
575 * of the result, or %NULL
577 * Guesses the content type based on example data. If the function is
578 * uncertain, @result_uncertain will be set to %TRUE. Either @filename
579 * or @data may be %NULL, in which case the guess will be based solely
580 * on the other argument.
582 * Returns: a string indicating a guessed content type for the
583 * given data. Free with g_free()
586 g_content_type_guess (const gchar
*filename
,
589 gboolean
*result_uncertain
)
592 const char *name_mimetypes
[10], *sniffed_mimetype
;
595 int n_name_mimetypes
;
599 n_name_mimetypes
= 0;
600 sniffed_mimetype
= XDG_MIME_TYPE_UNKNOWN
;
602 if (result_uncertain
)
603 *result_uncertain
= FALSE
;
605 /* our test suite and potentially other code used -1 in the past, which is
606 * not documented and not allowed; guard against that */
607 g_return_val_if_fail (data_size
!= (gsize
) -1, g_strdup (XDG_MIME_TYPE_UNKNOWN
));
609 G_LOCK (gio_xdgmime
);
613 i
= strlen (filename
);
614 if (filename
[i
- 1] == '/')
616 name_mimetypes
[0] = "inode/directory";
617 name_mimetypes
[1] = NULL
;
618 n_name_mimetypes
= 1;
619 if (result_uncertain
)
620 *result_uncertain
= TRUE
;
624 basename
= g_path_get_basename (filename
);
625 n_name_mimetypes
= xdg_mime_get_mime_types_from_file_name (basename
, name_mimetypes
, 10);
630 /* Got an extension match, and no conflicts. This is it. */
631 if (n_name_mimetypes
== 1)
633 G_UNLOCK (gio_xdgmime
);
634 return g_strdup (name_mimetypes
[0]);
639 sniffed_mimetype
= xdg_mime_get_mime_type_for_data (data
, data_size
, &sniffed_prio
);
640 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
642 looks_like_text (data
, data_size
))
643 sniffed_mimetype
= "text/plain";
645 /* For security reasons we don't ever want to sniff desktop files
646 * where we know the filename and it doesn't have a .desktop extension.
647 * This is because desktop files allow executing any application and
648 * we don't want to make it possible to hide them looking like something
651 if (filename
!= NULL
&&
652 strcmp (sniffed_mimetype
, "application/x-desktop") == 0)
653 sniffed_mimetype
= "text/plain";
656 if (n_name_mimetypes
== 0)
658 if (sniffed_mimetype
== XDG_MIME_TYPE_UNKNOWN
&&
660 *result_uncertain
= TRUE
;
662 mimetype
= g_strdup (sniffed_mimetype
);
667 if (sniffed_mimetype
!= XDG_MIME_TYPE_UNKNOWN
)
669 if (sniffed_prio
>= 80) /* High priority sniffing match, use that */
670 mimetype
= g_strdup (sniffed_mimetype
);
673 /* There are conflicts between the name matches and we
674 * have a sniffed type, use that as a tie breaker.
676 for (i
= 0; i
< n_name_mimetypes
; i
++)
678 if ( xdg_mime_mime_type_subclass (name_mimetypes
[i
], sniffed_mimetype
))
680 /* This nametype match is derived from (or the same as)
681 * the sniffed type). This is probably it.
683 mimetype
= g_strdup (name_mimetypes
[i
]);
690 if (mimetype
== NULL
)
692 /* Conflicts, and sniffed type was no help or not there.
693 * Guess on the first one
695 mimetype
= g_strdup (name_mimetypes
[0]);
696 if (result_uncertain
)
697 *result_uncertain
= TRUE
;
701 G_UNLOCK (gio_xdgmime
);
707 enumerate_mimetypes_subdir (const char *dir
,
709 GHashTable
*mimetypes
)
718 while ((ent
= readdir (d
)) != NULL
)
720 if (g_str_has_suffix (ent
->d_name
, ".xml"))
722 mimetype
= g_strdup_printf ("%s/%.*s", prefix
, (int) strlen (ent
->d_name
) - 4, ent
->d_name
);
723 g_hash_table_replace (mimetypes
, mimetype
, NULL
);
731 enumerate_mimetypes_dir (const char *dir
,
732 GHashTable
*mimetypes
)
739 mimedir
= g_build_filename (dir
, "mime", NULL
);
741 d
= opendir (mimedir
);
744 while ((ent
= readdir (d
)) != NULL
)
746 if (strcmp (ent
->d_name
, "packages") != 0)
748 name
= g_build_filename (mimedir
, ent
->d_name
, NULL
);
749 if (g_file_test (name
, G_FILE_TEST_IS_DIR
))
750 enumerate_mimetypes_subdir (name
, ent
->d_name
, mimetypes
);
761 * g_content_types_get_registered:
763 * Gets a list of strings containing all the registered content types
764 * known to the system. The list and its data should be freed using
766 * g_list_free_full (list, g_free);
769 * Returns: (element-type utf8) (transfer full): #GList of the registered content types
772 g_content_types_get_registered (void)
774 const char * const* dirs
;
775 GHashTable
*mimetypes
;
781 mimetypes
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, NULL
);
783 enumerate_mimetypes_dir (g_get_user_data_dir (), mimetypes
);
784 dirs
= g_get_system_data_dirs ();
786 for (i
= 0; dirs
[i
] != NULL
; i
++)
787 enumerate_mimetypes_dir (dirs
[i
], mimetypes
);
790 g_hash_table_iter_init (&iter
, mimetypes
);
791 while (g_hash_table_iter_next (&iter
, &key
, NULL
))
793 l
= g_list_prepend (l
, key
);
794 g_hash_table_iter_steal (&iter
);
797 g_hash_table_destroy (mimetypes
);
803 /* tree magic data */
804 static GList
*tree_matches
= NULL
;
805 static gboolean need_reload
= FALSE
;
807 G_LOCK_DEFINE_STATIC (gio_treemagic
);
813 guint match_case
: 1;
814 guint executable
: 1;
830 tree_matchlet_free (TreeMatchlet
*matchlet
)
832 g_list_free_full (matchlet
->matches
, (GDestroyNotify
) tree_matchlet_free
);
833 g_free (matchlet
->path
);
834 g_free (matchlet
->mimetype
);
835 g_slice_free (TreeMatchlet
, matchlet
);
839 tree_match_free (TreeMatch
*match
)
841 g_list_free_full (match
->matches
, (GDestroyNotify
) tree_matchlet_free
);
842 g_free (match
->contenttype
);
843 g_slice_free (TreeMatch
, match
);
847 parse_header (gchar
*line
)
855 if (line
[0] != '[' || line
[len
- 1] != ']')
859 s
= strchr (line
, ':');
861 match
= g_slice_new0 (TreeMatch
);
862 match
->priority
= atoi (line
+ 1);
863 match
->contenttype
= g_strdup (s
+ 1);
868 static TreeMatchlet
*
869 parse_match_line (gchar
*line
,
873 TreeMatchlet
*matchlet
;
877 matchlet
= g_slice_new0 (TreeMatchlet
);
886 *depth
= atoi (line
);
887 s
= strchr (line
, '>');
893 matchlet
->path
= g_strdup (s
);
895 parts
= g_strsplit (s
, ",", 0);
896 if (strcmp (parts
[0], "=file") == 0)
897 matchlet
->type
= G_FILE_TYPE_REGULAR
;
898 else if (strcmp (parts
[0], "=directory") == 0)
899 matchlet
->type
= G_FILE_TYPE_DIRECTORY
;
900 else if (strcmp (parts
[0], "=link") == 0)
901 matchlet
->type
= G_FILE_TYPE_SYMBOLIC_LINK
;
903 matchlet
->type
= G_FILE_TYPE_UNKNOWN
;
904 for (i
= 1; parts
[i
]; i
++)
906 if (strcmp (parts
[i
], "executable") == 0)
907 matchlet
->executable
= 1;
908 else if (strcmp (parts
[i
], "match-case") == 0)
909 matchlet
->match_case
= 1;
910 else if (strcmp (parts
[i
], "non-empty") == 0)
911 matchlet
->non_empty
= 1;
912 else if (strcmp (parts
[i
], "on-disc") == 0)
913 matchlet
->on_disc
= 1;
915 matchlet
->mimetype
= g_strdup (parts
[i
]);
924 cmp_match (gconstpointer a
, gconstpointer b
)
926 const TreeMatch
*aa
= (const TreeMatch
*)a
;
927 const TreeMatch
*bb
= (const TreeMatch
*)b
;
929 return bb
->priority
- aa
->priority
;
933 insert_match (TreeMatch
*match
)
935 tree_matches
= g_list_insert_sorted (tree_matches
, match
, cmp_match
);
939 insert_matchlet (TreeMatch
*match
,
940 TreeMatchlet
*matchlet
,
944 match
->matches
= g_list_append (match
->matches
, matchlet
);
950 last
= g_list_last (match
->matches
);
953 tree_matchlet_free (matchlet
);
954 g_warning ("can't insert tree matchlet at depth %d", depth
);
958 m
= (TreeMatchlet
*) last
->data
;
961 last
= g_list_last (m
->matches
);
964 tree_matchlet_free (matchlet
);
965 g_warning ("can't insert tree matchlet at depth %d", depth
);
969 m
= (TreeMatchlet
*) last
->data
;
971 m
->matches
= g_list_append (m
->matches
, matchlet
);
976 read_tree_magic_from_directory (const gchar
*prefix
)
984 TreeMatchlet
*matchlet
;
987 filename
= g_build_filename (prefix
, "mime", "treemagic", NULL
);
989 if (g_file_get_contents (filename
, &text
, &len
, NULL
))
991 if (strcmp (text
, "MIME-TreeMagic") == 0)
993 lines
= g_strsplit (text
+ strlen ("MIME-TreeMagic") + 2, "\n", 0);
995 for (i
= 0; lines
[i
] && lines
[i
][0]; i
++)
997 if (lines
[i
][0] == '[')
999 match
= parse_header (lines
[i
]);
1000 insert_match (match
);
1004 matchlet
= parse_match_line (lines
[i
], &depth
);
1005 insert_matchlet (match
, matchlet
, depth
);
1012 g_warning ("%s: header not found, skipping\n", filename
);
1022 xdg_mime_reload (void *user_data
)
1028 tree_magic_shutdown (void)
1030 g_list_free_full (tree_matches
, (GDestroyNotify
) tree_match_free
);
1031 tree_matches
= NULL
;
1035 tree_magic_init (void)
1037 static gboolean initialized
= FALSE
;
1039 const gchar
* const * dirs
;
1046 xdg_mime_register_reload_callback (xdg_mime_reload
, NULL
, NULL
);
1052 need_reload
= FALSE
;
1054 tree_magic_shutdown ();
1056 dir
= g_get_user_data_dir ();
1057 read_tree_magic_from_directory (dir
);
1058 dirs
= g_get_system_data_dirs ();
1059 for (i
= 0; dirs
[i
]; i
++)
1060 read_tree_magic_from_directory (dirs
[i
]);
1064 /* a filtering enumerator */
1070 gboolean ignore_case
;
1072 gchar
**case_components
;
1073 GFileEnumerator
**enumerators
;
1078 component_match (Enumerator
*e
,
1082 gchar
*case_folded
, *key
;
1085 if (strcmp (name
, e
->components
[depth
]) == 0)
1088 if (!e
->ignore_case
)
1091 case_folded
= g_utf8_casefold (name
, -1);
1092 key
= g_utf8_collate_key (case_folded
, -1);
1094 found
= strcmp (key
, e
->case_components
[depth
]) == 0;
1096 g_free (case_folded
);
1103 next_match_recurse (Enumerator
*e
,
1112 if (e
->enumerators
[depth
] == NULL
)
1116 file
= next_match_recurse (e
, depth
- 1);
1119 e
->children
[depth
] = file
;
1120 e
->enumerators
[depth
] = g_file_enumerate_children (file
,
1121 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1122 G_FILE_QUERY_INFO_NONE
,
1127 if (e
->enumerators
[depth
] == NULL
)
1131 while ((info
= g_file_enumerator_next_file (e
->enumerators
[depth
], NULL
, NULL
)))
1133 name
= g_file_info_get_name (info
);
1134 if (component_match (e
, depth
, name
))
1136 file
= g_file_get_child (e
->children
[depth
], name
);
1137 g_object_unref (info
);
1140 g_object_unref (info
);
1143 g_object_unref (e
->enumerators
[depth
]);
1144 e
->enumerators
[depth
] = NULL
;
1145 g_object_unref (e
->children
[depth
]);
1146 e
->children
[depth
] = NULL
;
1151 enumerator_next (Enumerator
*e
)
1153 return next_match_recurse (e
, e
->depth
- 1);
1157 enumerator_new (GFile
*root
,
1159 gboolean ignore_case
)
1165 e
= g_new0 (Enumerator
, 1);
1166 e
->path
= g_strdup (path
);
1167 e
->ignore_case
= ignore_case
;
1169 e
->components
= g_strsplit (e
->path
, G_DIR_SEPARATOR_S
, -1);
1170 e
->depth
= g_strv_length (e
->components
);
1173 e
->case_components
= g_new0 (char *, e
->depth
+ 1);
1174 for (i
= 0; e
->components
[i
]; i
++)
1176 case_folded
= g_utf8_casefold (e
->components
[i
], -1);
1177 e
->case_components
[i
] = g_utf8_collate_key (case_folded
, -1);
1178 g_free (case_folded
);
1182 e
->children
= g_new0 (GFile
*, e
->depth
);
1183 e
->children
[0] = g_object_ref (root
);
1184 e
->enumerators
= g_new0 (GFileEnumerator
*, e
->depth
);
1185 e
->enumerators
[0] = g_file_enumerate_children (root
,
1186 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1187 G_FILE_QUERY_INFO_NONE
,
1195 enumerator_free (Enumerator
*e
)
1199 for (i
= 0; i
< e
->depth
; i
++)
1201 if (e
->enumerators
[i
])
1202 g_object_unref (e
->enumerators
[i
]);
1204 g_object_unref (e
->children
[i
]);
1207 g_free (e
->enumerators
);
1208 g_free (e
->children
);
1209 g_strfreev (e
->components
);
1210 if (e
->case_components
)
1211 g_strfreev (e
->case_components
);
1217 matchlet_match (TreeMatchlet
*matchlet
,
1227 e
= enumerator_new (root
, matchlet
->path
, !matchlet
->match_case
);
1231 file
= enumerator_next (e
);
1234 enumerator_free (e
);
1238 if (matchlet
->mimetype
)
1239 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1240 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
","
1241 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
;
1243 attrs
= G_FILE_ATTRIBUTE_STANDARD_TYPE
","
1244 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
;
1245 info
= g_file_query_info (file
,
1247 G_FILE_QUERY_INFO_NONE
,
1254 if (matchlet
->type
!= G_FILE_TYPE_UNKNOWN
&&
1255 g_file_info_get_file_type (info
) != matchlet
->type
)
1258 if (matchlet
->executable
&&
1259 !g_file_info_get_attribute_boolean (info
, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
))
1265 if (result
&& matchlet
->non_empty
)
1267 GFileEnumerator
*child_enum
;
1268 GFileInfo
*child_info
;
1270 child_enum
= g_file_enumerate_children (file
,
1271 G_FILE_ATTRIBUTE_STANDARD_NAME
,
1272 G_FILE_QUERY_INFO_NONE
,
1278 child_info
= g_file_enumerator_next_file (child_enum
, NULL
, NULL
);
1280 g_object_unref (child_info
);
1283 g_object_unref (child_enum
);
1289 if (result
&& matchlet
->mimetype
)
1291 if (strcmp (matchlet
->mimetype
, g_file_info_get_content_type (info
)) != 0)
1295 g_object_unref (info
);
1296 g_object_unref (file
);
1300 enumerator_free (e
);
1302 if (!matchlet
->matches
)
1305 for (l
= matchlet
->matches
; l
; l
= l
->next
)
1307 TreeMatchlet
*submatchlet
;
1309 submatchlet
= l
->data
;
1310 if (matchlet_match (submatchlet
, root
))
1318 match_match (TreeMatch
*match
,
1324 for (l
= match
->matches
; l
; l
= l
->next
)
1326 TreeMatchlet
*matchlet
= l
->data
;
1327 if (matchlet_match (matchlet
, root
))
1329 g_ptr_array_add (types
, g_strdup (match
->contenttype
));
1336 * g_content_type_guess_for_tree:
1337 * @root: the root of the tree to guess a type for
1339 * Tries to guess the type of the tree with root @root, by
1340 * looking at the files it contains. The result is an array
1341 * of content types, with the best guess coming first.
1343 * The types returned all have the form x-content/foo, e.g.
1344 * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
1345 * (for a camera memory card). See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
1346 * specification for more on x-content types.
1348 * This function is useful in the implementation of
1349 * g_mount_guess_content_type().
1351 * Returns: (transfer full) (array zero-terminated=1): an %NULL-terminated
1352 * array of zero or more content types. Free with g_strfreev()
1357 g_content_type_guess_for_tree (GFile
*root
)
1362 types
= g_ptr_array_new ();
1364 G_LOCK (gio_treemagic
);
1367 for (l
= tree_matches
; l
; l
= l
->next
)
1369 TreeMatch
*match
= l
->data
;
1370 match_match (match
, root
, types
);
1373 G_UNLOCK (gio_treemagic
);
1375 g_ptr_array_add (types
, NULL
);
1377 return (gchar
**)g_ptr_array_free (types
, FALSE
);