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, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 02111-1307, USA.
40 #include <netinet/in.h> /* for ntohl/ntohs */
45 #warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used.
49 #include <sys/types.h>
51 #include "xdgmimecache.h"
52 #include "xdgmimeint.h"
55 #define MAX(a,b) ((a) > (b) ? (a) : (b))
71 #define MAP_FAILED ((void *) -1)
74 #define MAJOR_VERSION 1
75 #define MINOR_VERSION 1
85 #define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
86 #define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
89 _xdg_mime_cache_ref (XdgMimeCache *cache)
96 _xdg_mime_cache_unref (XdgMimeCache *cache)
100 if (cache->ref_count == 0)
103 munmap (cache->buffer, cache->size);
110 _xdg_mime_cache_new_from_file (const char *file_name)
112 XdgMimeCache *cache = NULL;
119 /* Open the file and map it into memory */
120 fd = open (file_name, O_RDONLY|_O_BINARY, 0);
125 if (fstat (fd, &st) < 0 || st.st_size < 4)
128 buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
130 if (buffer == MAP_FAILED)
134 if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
135 GET_UINT16 (buffer, 2) != MINOR_VERSION)
137 munmap (buffer, st.st_size);
142 cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
143 cache->ref_count = 1;
144 cache->buffer = buffer;
145 cache->size = st.st_size;
151 #endif /* HAVE_MMAP */
157 cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
162 xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
163 xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
164 xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
165 xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
166 xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
170 for (i = range_start; i <= range_start + range_length; i++)
172 int valid_matchlet = TRUE;
174 if (i + data_length > len)
179 for (j = 0; j < data_length; j++)
181 if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
182 ((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
184 valid_matchlet = FALSE;
191 for (j = 0; j < data_length; j++)
193 if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
195 valid_matchlet = FALSE;
209 cache_magic_matchlet_compare (XdgMimeCache *cache,
214 xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
215 xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
219 if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
224 for (i = 0; i < n_children; i++)
226 if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
236 cache_magic_compare_to_data (XdgMimeCache *cache,
242 xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
243 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
244 xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
245 xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
249 for (i = 0; i < n_matchlets; i++)
251 if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
256 return cache->buffer + mimetype_offset;
264 cache_magic_lookup_data (XdgMimeCache *cache,
268 const char *mime_types[],
271 xdg_uint32_t list_offset;
272 xdg_uint32_t n_entries;
279 list_offset = GET_UINT32 (cache->buffer, 24);
280 n_entries = GET_UINT32 (cache->buffer, list_offset);
281 offset = GET_UINT32 (cache->buffer, list_offset + 8);
283 for (j = 0; j < n_entries; j++)
287 match = cache_magic_compare_to_data (cache, offset + 16 * j,
293 xdg_uint32_t mimetype_offset;
294 const char *non_match;
296 mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
297 non_match = cache->buffer + mimetype_offset;
299 for (n = 0; n < n_mime_types; n++)
302 _xdg_mime_mime_type_equal (mime_types[n], non_match))
303 mime_types[n] = NULL;
312 cache_alias_lookup (const char *alias)
315 int i, min, max, mid, cmp;
317 for (i = 0; _caches[i]; i++)
319 XdgMimeCache *cache = _caches[i];
320 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
321 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
328 mid = (min + max) / 2;
330 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
331 ptr = cache->buffer + offset;
332 cmp = strcmp (ptr, alias);
340 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
341 return cache->buffer + offset;
355 cache_glob_lookup_literal (const char *file_name,
356 const char *mime_types[],
360 int i, min, max, mid, cmp;
362 for (i = 0; _caches[i]; i++)
364 XdgMimeCache *cache = _caches[i];
365 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
366 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
373 mid = (min + max) / 2;
375 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid);
376 ptr = cache->buffer + offset;
377 cmp = strcmp (ptr, file_name);
385 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 4);
386 mime_types[0] = (const char *)(cache->buffer + offset);
397 cache_glob_lookup_fnmatch (const char *file_name,
398 MimeWeight mime_types[],
401 const char *mime_type;
407 for (i = 0; _caches[i]; i++)
409 XdgMimeCache *cache = _caches[i];
411 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
412 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
414 for (j = 0; j < n_entries && n < n_mime_types; j++)
416 xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j);
417 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 4);
418 int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 8);
419 ptr = cache->buffer + offset;
420 mime_type = cache->buffer + mimetype_offset;
422 /* FIXME: Not UTF-8 safe */
423 if (fnmatch (ptr, file_name, 0) == 0)
425 mime_types[n].mime = mime_type;
426 mime_types[n].weight = weight;
439 cache_glob_node_lookup_suffix (XdgMimeCache *cache,
440 xdg_uint32_t n_entries,
442 xdg_unichar_t *file_name,
445 MimeWeight mime_types[],
448 xdg_unichar_t character;
449 xdg_unichar_t match_char;
450 xdg_uint32_t mimetype_offset;
451 xdg_uint32_t n_children;
452 xdg_uint32_t child_offset;
455 int min, max, mid, n, i;
457 character = file_name[len - 1];
459 character = _xdg_ucs4_to_lower (character);
461 assert (character != 0);
467 mid = (min + max) / 2;
468 match_char = GET_UINT32 (cache->buffer, offset + 12 * mid);
469 if (match_char < character)
471 else if (match_char > character)
477 n_children = GET_UINT32 (cache->buffer, offset + 12 * mid + 4);
478 child_offset = GET_UINT32 (cache->buffer, offset + 12 * mid + 8);
482 n = cache_glob_node_lookup_suffix (cache,
483 n_children, child_offset,
492 while (n < n_mime_types && i < n_children)
494 match_char = GET_UINT32 (cache->buffer, child_offset + 12 * i);
498 mimetype_offset = GET_UINT32 (cache->buffer, child_offset + 12 * i + 4);
499 weight = GET_UINT32 (cache->buffer, child_offset + 12 * i + 8);
501 mime_types[n].mime = cache->buffer + mimetype_offset;
502 mime_types[n].weight = weight;
514 cache_glob_lookup_suffix (xdg_unichar_t *file_name,
517 MimeWeight mime_types[],
522 for (i = 0; _caches[i]; i++)
524 XdgMimeCache *cache = _caches[i];
526 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
527 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
528 xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
530 n = cache_glob_node_lookup_suffix (cache,
543 static int compare_mime_weight (const void *a, const void *b)
545 const MimeWeight *aa = (const MimeWeight *)a;
546 const MimeWeight *bb = (const MimeWeight *)b;
548 return aa->weight - bb->weight;
552 cache_glob_lookup_file_name (const char *file_name,
553 const char *mime_types[],
557 MimeWeight mimes[10];
563 assert (file_name != NULL && n_mime_types > 0);
565 /* First, check the literals */
566 n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types);
570 ucs4 = _xdg_convert_to_ucs4 (file_name, &len);
571 n = cache_glob_lookup_suffix (ucs4, len, FALSE, mimes, n_mimes);
574 n = cache_glob_lookup_suffix (ucs4, len, TRUE, mimes, n_mimes);
577 /* Last, try fnmatch */
579 n = cache_glob_lookup_fnmatch (file_name, mimes, n_mimes);
581 qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
583 if (n_mime_types < n)
586 for (i = 0; i < n; i++)
587 mime_types[i] = mimes[i].mime;
593 _xdg_mime_cache_get_max_buffer_extents (void)
596 xdg_uint32_t max_extent;
600 for (i = 0; _caches[i]; i++)
602 XdgMimeCache *cache = _caches[i];
604 offset = GET_UINT32 (cache->buffer, 24);
605 max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
612 cache_get_mime_type_for_data (const void *data,
615 const char *mime_types[],
618 const char *mime_type;
623 for (i = 0; _caches[i]; i++)
625 XdgMimeCache *cache = _caches[i];
630 match = cache_magic_lookup_data (cache, data, len, &prio,
631 mime_types, n_mime_types);
640 *result_prio = priority;
645 for (n = 0; n < n_mime_types; n++)
649 return mime_types[n];
652 return XDG_MIME_TYPE_UNKNOWN;
656 _xdg_mime_cache_get_mime_type_for_data (const void *data,
660 return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0);
664 _xdg_mime_cache_get_mime_type_for_file (const char *file_name,
665 struct stat *statbuf)
667 const char *mime_type;
668 const char *mime_types[10];
674 const char *base_name;
677 if (file_name == NULL)
680 if (! _xdg_utf8_validate (file_name))
683 base_name = _xdg_get_base_name (file_name);
684 n = cache_glob_lookup_file_name (base_name, mime_types, 10);
687 return mime_types[0];
691 if (stat (file_name, &buf) != 0)
692 return XDG_MIME_TYPE_UNKNOWN;
697 if (!S_ISREG (statbuf->st_mode))
698 return XDG_MIME_TYPE_UNKNOWN;
700 /* FIXME: Need to make sure that max_extent isn't totally broken. This could
701 * be large and need getting from a stream instead of just reading it all
703 max_extent = _xdg_mime_cache_get_max_buffer_extents ();
704 data = malloc (max_extent);
706 return XDG_MIME_TYPE_UNKNOWN;
708 file = fopen (file_name, "r");
712 return XDG_MIME_TYPE_UNKNOWN;
715 bytes_read = fread (data, 1, max_extent, file);
720 return XDG_MIME_TYPE_UNKNOWN;
723 mime_type = cache_get_mime_type_for_data (data, bytes_read, NULL,
733 _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
735 const char *mime_type;
737 if (cache_glob_lookup_file_name (file_name, &mime_type, 1))
740 return XDG_MIME_TYPE_UNKNOWN;
744 _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
745 const char *mime_types[],
748 return cache_glob_lookup_file_name (file_name, mime_types, n_mime_types);
753 is_super_type (const char *mime)
758 length = strlen (mime);
759 type = &(mime[length - 2]);
761 if (strcmp (type, "/*") == 0)
769 _xdg_mime_cache_mime_type_subclass (const char *mime,
772 const char *umime, *ubase;
774 int i, j, min, max, med, cmp;
776 umime = _xdg_mime_cache_unalias_mime_type (mime);
777 ubase = _xdg_mime_cache_unalias_mime_type (base);
779 if (strcmp (umime, ubase) == 0)
782 /* We really want to handle text/ * in GtkFileFilter, so we just
783 * turn on the supertype matching
786 /* Handle supertypes */
787 if (is_super_type (ubase) &&
788 xdg_mime_media_type_equal (umime, ubase))
792 /* Handle special cases text/plain and application/octet-stream */
793 if (strcmp (ubase, "text/plain") == 0 &&
794 strncmp (umime, "text/", 5) == 0)
797 if (strcmp (ubase, "application/octet-stream") == 0)
800 for (i = 0; _caches[i]; i++)
802 XdgMimeCache *cache = _caches[i];
804 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
805 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
806 xdg_uint32_t offset, n_parents, parent_offset;
814 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
815 cmp = strcmp (cache->buffer + offset, umime);
822 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
823 n_parents = GET_UINT32 (cache->buffer, offset);
825 for (j = 0; j < n_parents; j++)
827 parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
828 if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
841 _xdg_mime_cache_unalias_mime_type (const char *mime)
845 lookup = cache_alias_lookup (mime);
854 _xdg_mime_cache_list_mime_parents (const char *mime)
857 char *all_parents[128]; /* we'll stop at 128 */
860 mime = xdg_mime_unalias_mime_type (mime);
863 for (i = 0; _caches[i]; i++)
865 XdgMimeCache *cache = _caches[i];
867 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
868 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
870 for (j = 0; j < n_entries; j++)
872 xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
873 xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
875 if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
877 xdg_uint32_t parent_mime_offset;
878 xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
880 for (k = 0; k < n_parents && p < 127; k++)
882 parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
884 /* Don't add same parent multiple times.
885 * This can happen for instance if the same type is listed in multiple directories
887 for (l = 0; l < p; l++)
889 if (strcmp (all_parents[l], cache->buffer + parent_mime_offset) == 0)
894 all_parents[p++] = cache->buffer + parent_mime_offset;
901 all_parents[p++] = NULL;
903 result = (char **) malloc (p * sizeof (char *));
904 memcpy (result, all_parents, p * sizeof (char *));
910 cache_lookup_icon (const char *mime, int header)
913 int i, min, max, mid, cmp;
915 for (i = 0; _caches[i]; i++)
917 XdgMimeCache *cache = _caches[i];
918 xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, header);
919 xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
926 mid = (min + max) / 2;
928 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
929 ptr = cache->buffer + offset;
930 cmp = strcmp (ptr, mime);
938 offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
939 return cache->buffer + offset;
948 _xdg_mime_cache_get_generic_icon (const char *mime)
950 return cache_lookup_icon (mime, 36);
954 _xdg_mime_cache_get_icon (const char *mime)
958 icon = cache_lookup_icon (mime, 32);
961 icon = _xdg_mime_cache_get_generic_icon (mime);
967 dump_glob_node (XdgMimeCache *cache,
971 xdg_unichar_t character;
972 xdg_uint32_t mime_offset;
973 xdg_uint32_t n_children;
974 xdg_uint32_t child_offset;
977 character = GET_UINT32 (cache->buffer, offset);
978 mime_offset = GET_UINT32 (cache->buffer, offset + 4);
979 n_children = GET_UINT32 (cache->buffer, offset + 8);
980 child_offset = GET_UINT32 (cache->buffer, offset + 12);
981 for (i = 0; i < depth; i++)
983 printf ("%c", character);
985 printf (" - %s", cache->buffer + mime_offset);
989 for (i = 0; i < n_children; i++)
990 dump_glob_node (cache, child_offset + 20 * i, depth + 1);
995 _xdg_mime_cache_glob_dump (void)
998 for (i = 0; _caches[i]; i++)
1000 XdgMimeCache *cache = _caches[i];
1001 xdg_uint32_t list_offset;
1002 xdg_uint32_t n_entries;
1003 xdg_uint32_t offset;
1004 list_offset = GET_UINT32 (cache->buffer, 16);
1005 n_entries = GET_UINT32 (cache->buffer, list_offset);
1006 offset = GET_UINT32 (cache->buffer, list_offset + 4);
1007 for (j = 0; j < n_entries; j++)
1008 dump_glob_node (cache, offset + 20 * j, 0);