1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* xdgmimealias.c: Private file. mmappable caches for mime data
4 * More info can be found at http://www.freedesktop.org/standards/
6 * Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
8 * Licensed under the Academic Free License version 2.0
9 * Or under the following terms:
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
39 #include <netinet/in.h> /* for ntohl/ntohs */
44 #warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used.
48 #include <sys/types.h>
50 #include "xdgmimecache.h"
51 #include "xdgmimeint.h"
54 #define MAX(a,b) ((a) > (b) ? (a) : (b))
70 #define MAP_FAILED ((void *) -1)
73 #define MAJOR_VERSION 1
74 #define MINOR_VERSION_MIN 1
75 #define MINOR_VERSION_MAX 2
86 #define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
87 #define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
90 _xdg_mime_cache_ref (XdgMimeCache *cache)
97 _xdg_mime_cache_unref (XdgMimeCache *cache)
101 if (cache->ref_count == 0)
104 munmap (cache->buffer, cache->size);
111 _xdg_mime_cache_new_from_file (const char *file_name)
113 XdgMimeCache *cache = NULL;
121 /* Open the file and map it into memory */
123 fd = open (file_name, O_RDONLY|_O_BINARY, 0);
124 while (fd == -1 && errno == EINTR);
129 if (fstat (fd, &st) < 0 || st.st_size < 4)
132 buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
134 if (buffer == MAP_FAILED)
137 minor = GET_UINT16 (buffer, 2);
139 if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
140 (minor < MINOR_VERSION_MIN ||
141 minor > MINOR_VERSION_MAX))
143 munmap (buffer, st.st_size);
148 cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
149 cache->minor = minor;
150 cache->ref_count = 1;
151 cache->buffer = buffer;
152 cache->size = st.st_size;
158 #endif /* HAVE_MMAP */
164 cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
169 xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
170 xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
171 xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
172 xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
173 xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
177 for (i = range_start; i < range_start + range_length; i++)
179 int valid_matchlet = TRUE;
181 if (i + data_length > len)
186 for (j = 0; j < data_length; j++)
188 if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
189 ((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
191 valid_matchlet = FALSE;
198 for (j = 0; j < data_length; j++)
200 if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
202 valid_matchlet = FALSE;
216 cache_magic_matchlet_compare (XdgMimeCache *cache,
221 xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
222 xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
226 if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
231 for (i = 0; i < n_children; i++)
233 if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
243 cache_magic_compare_to_data (XdgMimeCache *cache,
249 xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
250 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
251 xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
252 xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
256 for (i = 0; i < n_matchlets; i++)
258 if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
263 return cache->buffer + mimetype_offset;
271 cache_magic_lookup_data (XdgMimeCache *cache,
275 const char *mime_types[],
278 xdg_uint32_t list_offset;
279 xdg_uint32_t n_entries;
286 list_offset = GET_UINT32 (cache->buffer, 24);
287 n_entries = GET_UINT32 (cache->buffer, list_offset);
288 offset = GET_UINT32 (cache->buffer, list_offset + 8);
290 for (j = 0; j < n_entries; j++)
294 match = cache_magic_compare_to_data (cache, offset + 16 * j,
300 xdg_uint32_t mimetype_offset;
301 const char *non_match;
303 mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
304 non_match = cache->buffer + mimetype_offset;
306 for (n = 0; n < n_mime_types; n++)
309 _xdg_mime_mime_type_equal (mime_types[n], non_match))
310 mime_types[n] = NULL;
319 cache_alias_lookup (const char *alias)
322 int i, min, max, mid, cmp;
324 for (i = 0; _caches[i]; i++)
326 XdgMimeCache *cache = _caches[i];
327 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
328 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
335 mid = (min + max) / 2;
337 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
338 ptr = cache->buffer + offset;
339 cmp = strcmp (ptr, alias);
347 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
348 return cache->buffer + offset;
362 cache_glob_lookup_literal (const char *file_name,
363 const char *mime_types[],
365 int case_sensitive_check)
368 int i, min, max, mid, cmp;
370 for (i = 0; _caches[i]; i++)
372 XdgMimeCache *cache = _caches[i];
373 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
374 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
381 mid = (min + max) / 2;
383 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid);
384 ptr = cache->buffer + offset;
385 cmp = strcmp (ptr, file_name);
393 int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 8);
394 int case_sensitive = weight & 0x100;
395 weight = weight & 0xff;
397 if (case_sensitive_check || !case_sensitive)
399 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 4);
400 mime_types[0] = (const char *)(cache->buffer + offset);
413 cache_glob_lookup_fnmatch (const char *file_name,
414 MimeWeight mime_types[],
417 const char *mime_type;
423 for (i = 0; _caches[i]; i++)
425 XdgMimeCache *cache = _caches[i];
427 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
428 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
430 for (j = 0; j < n_entries && n < n_mime_types; j++)
432 xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j);
433 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 4);
434 int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 8);
435 weight = weight & 0xff;
436 ptr = cache->buffer + offset;
437 mime_type = cache->buffer + mimetype_offset;
439 /* FIXME: Not UTF-8 safe */
440 if (fnmatch (ptr, file_name, 0) == 0)
442 mime_types[n].mime = mime_type;
443 mime_types[n].weight = weight;
448 if (n == n_mime_types)
456 cache_glob_node_lookup_suffix (XdgMimeCache *cache,
457 xdg_uint32_t n_entries,
459 const char *file_name,
461 int case_sensitive_check,
462 MimeWeight mime_types[],
465 xdg_unichar_t character;
466 xdg_unichar_t match_char;
467 xdg_uint32_t mimetype_offset;
468 xdg_uint32_t n_children;
469 xdg_uint32_t child_offset;
473 int min, max, mid, n, i;
475 character = file_name[len - 1];
477 assert (character != 0);
483 mid = (min + max) / 2;
484 match_char = GET_UINT32 (cache->buffer, offset + 12 * mid);
485 if (match_char < character)
487 else if (match_char > character)
493 n_children = GET_UINT32 (cache->buffer, offset + 12 * mid + 4);
494 child_offset = GET_UINT32 (cache->buffer, offset + 12 * mid + 8);
498 n = cache_glob_node_lookup_suffix (cache,
499 n_children, child_offset,
501 case_sensitive_check,
508 while (n < n_mime_types && i < n_children)
510 match_char = GET_UINT32 (cache->buffer, child_offset + 12 * i);
514 mimetype_offset = GET_UINT32 (cache->buffer, child_offset + 12 * i + 4);
515 weight = GET_UINT32 (cache->buffer, child_offset + 12 * i + 8);
516 case_sensitive = weight & 0x100;
517 weight = weight & 0xff;
519 if (case_sensitive_check || !case_sensitive)
521 mime_types[n].mime = cache->buffer + mimetype_offset;
522 mime_types[n].weight = weight;
535 cache_glob_lookup_suffix (const char *file_name,
538 MimeWeight mime_types[],
544 for (i = 0; _caches[i]; i++)
546 XdgMimeCache *cache = _caches[i];
548 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
549 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
550 xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
552 n += cache_glob_node_lookup_suffix (cache,
558 if (n == n_mime_types)
565 static int compare_mime_weight (const void *a, const void *b)
567 const MimeWeight *aa = (const MimeWeight *)a;
568 const MimeWeight *bb = (const MimeWeight *)b;
570 return bb->weight - aa->weight;
573 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
575 ascii_tolower (const char *str)
579 lower = strdup (str);
584 *p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
590 filter_out_dupes (MimeWeight mimes[], int n_mimes)
597 for (i = 0; i < last; i++)
602 if (strcmp (mimes[i].mime, mimes[j].mime) == 0)
604 mimes[i].weight = MAX (mimes[i].weight, mimes[j].weight);
606 mimes[j].mime = mimes[last].mime;
607 mimes[j].weight = mimes[last].weight;
618 cache_glob_lookup_file_name (const char *file_name,
619 const char *mime_types[],
623 MimeWeight mimes[10];
629 assert (file_name != NULL && n_mime_types > 0);
631 /* First, check the literals */
633 lower_case = ascii_tolower (file_name);
635 n = cache_glob_lookup_literal (lower_case, mime_types, n_mime_types, FALSE);
642 n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types, TRUE);
649 len = strlen (file_name);
650 n = cache_glob_lookup_suffix (lower_case, len, FALSE, mimes, n_mimes);
652 n += cache_glob_lookup_suffix (file_name, len, TRUE, mimes + n, n_mimes - n);
656 /* Last, try fnmatch */
658 n += cache_glob_lookup_fnmatch (file_name, mimes + n, n_mimes - n);
660 n = filter_out_dupes (mimes, n);
662 qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
664 if (n_mime_types < n)
667 for (i = 0; i < n; i++)
668 mime_types[i] = mimes[i].mime;
674 _xdg_mime_cache_get_max_buffer_extents (void)
677 xdg_uint32_t max_extent;
681 for (i = 0; _caches[i]; i++)
683 XdgMimeCache *cache = _caches[i];
685 offset = GET_UINT32 (cache->buffer, 24);
686 max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
693 cache_get_mime_type_for_data (const void *data,
696 const char *mime_types[],
699 const char *mime_type;
704 for (i = 0; _caches[i]; i++)
706 XdgMimeCache *cache = _caches[i];
711 match = cache_magic_lookup_data (cache, data, len, &prio,
712 mime_types, n_mime_types);
721 *result_prio = priority;
726 for (n = 0; n < n_mime_types; n++)
730 return mime_types[n];
733 return XDG_MIME_TYPE_UNKNOWN;
737 _xdg_mime_cache_get_mime_type_for_data (const void *data,
741 return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0);
744 #ifdef NOT_USED_IN_GIO
747 _xdg_mime_cache_get_mime_type_for_file (const char *file_name,
748 struct stat *statbuf)
750 const char *mime_type;
751 const char *mime_types[10];
757 const char *base_name;
760 if (file_name == NULL)
763 if (! _xdg_utf8_validate (file_name))
766 base_name = _xdg_get_base_name (file_name);
767 n = cache_glob_lookup_file_name (base_name, mime_types, 10);
770 return mime_types[0];
774 if (stat (file_name, &buf) != 0)
775 return XDG_MIME_TYPE_UNKNOWN;
780 if (!S_ISREG (statbuf->st_mode))
781 return XDG_MIME_TYPE_UNKNOWN;
783 /* FIXME: Need to make sure that max_extent isn't totally broken. This could
784 * be large and need getting from a stream instead of just reading it all
786 max_extent = _xdg_mime_cache_get_max_buffer_extents ();
787 data = malloc (max_extent);
789 return XDG_MIME_TYPE_UNKNOWN;
791 file = fopen (file_name, "r");
795 return XDG_MIME_TYPE_UNKNOWN;
798 bytes_read = fread (data, 1, max_extent, file);
803 return XDG_MIME_TYPE_UNKNOWN;
806 mime_type = cache_get_mime_type_for_data (data, bytes_read, NULL,
816 _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
818 const char *mime_type;
820 if (cache_glob_lookup_file_name (file_name, &mime_type, 1))
823 return XDG_MIME_TYPE_UNKNOWN;
829 _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
830 const char *mime_types[],
833 return cache_glob_lookup_file_name (file_name, mime_types, n_mime_types);
838 ends_with (const char *str,
844 length = strlen (str);
845 suffix_length = strlen (suffix);
846 if (length < suffix_length)
849 if (strcmp (str + length - suffix_length, suffix) == 0)
856 is_super_type (const char *mime)
858 return ends_with (mime, "/*");
863 _xdg_mime_cache_mime_type_subclass (const char *mime,
866 const char *umime, *ubase;
868 int i, j, min, max, med, cmp;
870 umime = _xdg_mime_cache_unalias_mime_type (mime);
871 ubase = _xdg_mime_cache_unalias_mime_type (base);
873 if (strcmp (umime, ubase) == 0)
876 /* We really want to handle text/ * in GtkFileFilter, so we just
877 * turn on the supertype matching
880 /* Handle supertypes */
881 if (is_super_type (ubase) &&
882 xdg_mime_media_type_equal (umime, ubase))
886 /* Handle special cases text/plain and application/octet-stream */
887 if (strcmp (ubase, "text/plain") == 0 &&
888 strncmp (umime, "text/", 5) == 0)
891 if (strcmp (ubase, "application/octet-stream") == 0)
894 for (i = 0; _caches[i]; i++)
896 XdgMimeCache *cache = _caches[i];
898 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
899 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
900 xdg_uint32_t offset, n_parents, parent_offset;
908 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
909 cmp = strcmp (cache->buffer + offset, umime);
916 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
917 n_parents = GET_UINT32 (cache->buffer, offset);
919 for (j = 0; j < n_parents; j++)
921 parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
922 if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
935 _xdg_mime_cache_unalias_mime_type (const char *mime)
939 lookup = cache_alias_lookup (mime);
948 _xdg_mime_cache_list_mime_parents (const char *mime)
951 char *all_parents[128]; /* we'll stop at 128 */
954 mime = xdg_mime_unalias_mime_type (mime);
957 for (i = 0; _caches[i]; i++)
959 XdgMimeCache *cache = _caches[i];
961 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
962 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
964 for (j = 0; j < n_entries; j++)
966 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
967 xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
969 if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
971 xdg_uint32_t parent_mime_offset;
972 xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
974 for (k = 0; k < n_parents && p < 127; k++)
976 parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
978 /* Don't add same parent multiple times.
979 * This can happen for instance if the same type is listed in multiple directories
981 for (l = 0; l < p; l++)
983 if (strcmp (all_parents[l], cache->buffer + parent_mime_offset) == 0)
988 all_parents[p++] = cache->buffer + parent_mime_offset;
995 all_parents[p++] = NULL;
997 result = (char **) malloc (p * sizeof (char *));
998 memcpy (result, all_parents, p * sizeof (char *));
1004 cache_lookup_icon (const char *mime, int header)
1007 int i, min, max, mid, cmp;
1009 for (i = 0; _caches[i]; i++)
1011 XdgMimeCache *cache = _caches[i];
1012 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, header);
1013 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
1014 xdg_uint32_t offset;
1017 max = n_entries - 1;
1020 mid = (min + max) / 2;
1022 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
1023 ptr = cache->buffer + offset;
1024 cmp = strcmp (ptr, mime);
1032 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
1033 return cache->buffer + offset;
1042 _xdg_mime_cache_get_generic_icon (const char *mime)
1044 return cache_lookup_icon (mime, 36);
1048 _xdg_mime_cache_get_icon (const char *mime)
1050 return cache_lookup_icon (mime, 32);
1053 #ifdef NOT_USED_IN_GIO
1056 dump_glob_node (XdgMimeCache *cache,
1057 xdg_uint32_t offset,
1060 xdg_unichar_t character;
1061 xdg_uint32_t mime_offset;
1062 xdg_uint32_t n_children;
1063 xdg_uint32_t child_offset;
1066 character = GET_UINT32 (cache->buffer, offset);
1067 mime_offset = GET_UINT32 (cache->buffer, offset + 4);
1068 n_children = GET_UINT32 (cache->buffer, offset + 8);
1069 child_offset = GET_UINT32 (cache->buffer, offset + 12);
1070 for (i = 0; i < depth; i++)
1072 printf ("%c", character);
1074 printf (" - %s", cache->buffer + mime_offset);
1078 for (i = 0; i < n_children; i++)
1079 dump_glob_node (cache, child_offset + 20 * i, depth + 1);
1084 _xdg_mime_cache_glob_dump (void)
1087 for (i = 0; _caches[i]; i++)
1089 XdgMimeCache *cache = _caches[i];
1090 xdg_uint32_t list_offset;
1091 xdg_uint32_t n_entries;
1092 xdg_uint32_t offset;
1093 list_offset = GET_UINT32 (cache->buffer, 16);
1094 n_entries = GET_UINT32 (cache->buffer, list_offset);
1095 offset = GET_UINT32 (cache->buffer, list_offset + 4);
1096 for (j = 0; j < n_entries; j++)
1097 dump_glob_node (cache, offset + 20 * j, 0);