Branch data Line data Source code
1 : : /* -*- mode: C; c-file-style: "gnu" -*- */
2 : : /* xdgmimealias.c: Private file. mmappable caches for mime data
3 : : *
4 : : * More info can be found at http://www.freedesktop.org/standards/
5 : : *
6 : : * Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
7 : : *
8 : : * Licensed under the Academic Free License version 2.0
9 : : * Or under the following terms:
10 : : *
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.
15 : : *
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.
20 : : *
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.
25 : : */
26 : :
27 : : #ifdef HAVE_CONFIG_H
28 : : #include <config.h>
29 : : #endif
30 : :
31 : : #include <stdio.h>
32 : : #include <stdlib.h>
33 : : #include <string.h>
34 : :
35 : : #include <fcntl.h>
36 : : #include <unistd.h>
37 : : #include <fnmatch.h>
38 : : #include <assert.h>
39 : :
40 : : #include <netinet/in.h> /* for ntohl/ntohs */
41 : :
42 : : #ifdef HAVE_MMAP
43 : : #include <sys/mman.h>
44 : : #else
45 : : #warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used.
46 : : #endif
47 : :
48 : : #include <sys/stat.h>
49 : : #include <sys/types.h>
50 : :
51 : : #include "xdgmimecache.h"
52 : : #include "xdgmimeint.h"
53 : :
54 : : #ifndef MAX
55 : : #define MAX(a,b) ((a) > (b) ? (a) : (b))
56 : : #endif
57 : :
58 : : #ifndef FALSE
59 : : #define FALSE (0)
60 : : #endif
61 : :
62 : : #ifndef TRUE
63 : : #define TRUE (!FALSE)
64 : : #endif
65 : :
66 : : #ifndef _O_BINARY
67 : : #define _O_BINARY 0
68 : : #endif
69 : :
70 : : #ifndef MAP_FAILED
71 : : #define MAP_FAILED ((void *) -1)
72 : : #endif
73 : :
74 : : #define MAJOR_VERSION 1
75 : : #define MINOR_VERSION 0
76 : :
77 : : struct _XdgMimeCache
78 : : {
79 : : int ref_count;
80 : :
81 : : size_t size;
82 : : char *buffer;
83 : : };
84 : :
85 : : #define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
86 : : #define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
87 : :
88 : : XdgMimeCache *
89 : 0 : _xdg_mime_cache_ref (XdgMimeCache *cache)
90 : : {
91 : 0 : cache->ref_count++;
92 : 0 : return cache;
93 : : }
94 : :
95 : : void
96 : 0 : _xdg_mime_cache_unref (XdgMimeCache *cache)
97 : : {
98 : 0 : cache->ref_count--;
99 : :
100 [ # # ]: 0 : if (cache->ref_count == 0)
101 : : {
102 : : #ifdef HAVE_MMAP
103 : 0 : munmap (cache->buffer, cache->size);
104 : : #endif
105 : 0 : free (cache);
106 : : }
107 : 0 : }
108 : :
109 : : XdgMimeCache *
110 : 6 : _xdg_mime_cache_new_from_file (const char *file_name)
111 : : {
112 : 6 : XdgMimeCache *cache = NULL;
113 : :
114 : : #ifdef HAVE_MMAP
115 : 6 : int fd = -1;
116 : : struct stat st;
117 : 6 : char *buffer = NULL;
118 : :
119 : : /* Open the file and map it into memory */
120 : 6 : fd = open (file_name, O_RDONLY|_O_BINARY, 0);
121 : :
122 [ - + ]: 6 : if (fd < 0)
123 : 0 : return NULL;
124 : :
125 [ + - ][ + - ]: 6 : if (fstat (fd, &st) < 0 || st.st_size < 4)
126 : : goto done;
127 : :
128 : 6 : buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
129 : :
130 [ - + ]: 6 : if (buffer == MAP_FAILED)
131 : 0 : goto done;
132 : :
133 : : /* Verify version */
134 [ + - + - ]: 12 : if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
135 : 6 : GET_UINT16 (buffer, 2) != MINOR_VERSION)
136 : : {
137 : 6 : munmap (buffer, st.st_size);
138 : :
139 : 6 : goto done;
140 : : }
141 : :
142 : 0 : cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
143 : 0 : cache->ref_count = 1;
144 : 0 : cache->buffer = buffer;
145 : 0 : cache->size = st.st_size;
146 : :
147 : : done:
148 [ + - ]: 6 : if (fd != -1)
149 : 6 : close (fd);
150 : :
151 : : #endif /* HAVE_MMAP */
152 : :
153 : 6 : return cache;
154 : : }
155 : :
156 : : static int
157 : 0 : cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
158 : : xdg_uint32_t offset,
159 : : const void *data,
160 : : size_t len)
161 : : {
162 : 0 : xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
163 : 0 : xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
164 : 0 : xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
165 : 0 : xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
166 : 0 : xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
167 : :
168 : : int i, j;
169 : :
170 [ # # ]: 0 : for (i = range_start; i <= range_start + range_length; i++)
171 : : {
172 : 0 : int valid_matchlet = TRUE;
173 : :
174 [ # # ]: 0 : if (i + data_length > len)
175 : 0 : return FALSE;
176 : :
177 [ # # ]: 0 : if (mask_offset)
178 : : {
179 [ # # ]: 0 : for (j = 0; j < data_length; j++)
180 : : {
181 [ # # ]: 0 : if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
182 : 0 : ((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
183 : : {
184 : 0 : valid_matchlet = FALSE;
185 : 0 : break;
186 : : }
187 : : }
188 : : }
189 : : else
190 : : {
191 [ # # ]: 0 : for (j = 0; j < data_length; j++)
192 : : {
193 [ # # ]: 0 : if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
194 : : {
195 : 0 : valid_matchlet = FALSE;
196 : 0 : break;
197 : : }
198 : : }
199 : : }
200 : :
201 [ # # ]: 0 : if (valid_matchlet)
202 : 0 : return TRUE;
203 : : }
204 : :
205 : 0 : return FALSE;
206 : : }
207 : :
208 : : static int
209 : 0 : cache_magic_matchlet_compare (XdgMimeCache *cache,
210 : : xdg_uint32_t offset,
211 : : const void *data,
212 : : size_t len)
213 : : {
214 : 0 : xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
215 : 0 : xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
216 : :
217 : : int i;
218 : :
219 [ # # ]: 0 : if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
220 : : {
221 [ # # ]: 0 : if (n_children == 0)
222 : 0 : return TRUE;
223 : :
224 [ # # ]: 0 : for (i = 0; i < n_children; i++)
225 : : {
226 [ # # ]: 0 : if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
227 : : data, len))
228 : 0 : return TRUE;
229 : : }
230 : : }
231 : :
232 : 0 : return FALSE;
233 : : }
234 : :
235 : : static const char *
236 : 0 : cache_magic_compare_to_data (XdgMimeCache *cache,
237 : : xdg_uint32_t offset,
238 : : const void *data,
239 : : size_t len,
240 : : int *prio)
241 : : {
242 : 0 : xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
243 : 0 : xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
244 : 0 : xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
245 : 0 : xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
246 : :
247 : : int i;
248 : :
249 [ # # ]: 0 : for (i = 0; i < n_matchlets; i++)
250 : : {
251 [ # # ]: 0 : if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
252 : : data, len))
253 : : {
254 : 0 : *prio = priority;
255 : :
256 : 0 : return cache->buffer + mimetype_offset;
257 : : }
258 : : }
259 : :
260 : 0 : return NULL;
261 : : }
262 : :
263 : : static const char *
264 : 0 : cache_magic_lookup_data (XdgMimeCache *cache,
265 : : const void *data,
266 : : size_t len,
267 : : int *prio,
268 : : const char *mime_types[],
269 : : int n_mime_types)
270 : : {
271 : : xdg_uint32_t list_offset;
272 : : xdg_uint32_t n_entries;
273 : : xdg_uint32_t offset;
274 : :
275 : : int j, n;
276 : :
277 : 0 : *prio = 0;
278 : :
279 : 0 : list_offset = GET_UINT32 (cache->buffer, 24);
280 : 0 : n_entries = GET_UINT32 (cache->buffer, list_offset);
281 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 8);
282 : :
283 [ # # ]: 0 : for (j = 0; j < n_entries; j++)
284 : : {
285 : : const char *match;
286 : :
287 : 0 : match = cache_magic_compare_to_data (cache, offset + 16 * j,
288 : : data, len, prio);
289 [ # # ]: 0 : if (match)
290 : 0 : return match;
291 : : else
292 : : {
293 : : xdg_uint32_t mimetype_offset;
294 : : const char *non_match;
295 : :
296 : 0 : mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
297 : 0 : non_match = cache->buffer + mimetype_offset;
298 : :
299 [ # # ]: 0 : for (n = 0; n < n_mime_types; n++)
300 : : {
301 [ # # # # ]: 0 : if (mime_types[n] &&
302 : 0 : xdg_mime_mime_type_equal (mime_types[n], non_match))
303 : 0 : mime_types[n] = NULL;
304 : : }
305 : : }
306 : : }
307 : :
308 : 0 : return NULL;
309 : : }
310 : :
311 : : static const char *
312 : 0 : cache_alias_lookup (const char *alias)
313 : : {
314 : : const char *ptr;
315 : : int i, min, max, mid, cmp;
316 : :
317 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
318 : : {
319 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
320 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
321 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
322 : : xdg_uint32_t offset;
323 : :
324 : 0 : min = 0;
325 : 0 : max = n_entries - 1;
326 [ # # ]: 0 : while (max >= min)
327 : : {
328 : 0 : mid = (min + max) / 2;
329 : :
330 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
331 : 0 : ptr = cache->buffer + offset;
332 : 0 : cmp = strcmp (ptr, alias);
333 : :
334 [ # # ]: 0 : if (cmp < 0)
335 : 0 : min = mid + 1;
336 [ # # ]: 0 : else if (cmp > 0)
337 : 0 : max = mid - 1;
338 : : else
339 : : {
340 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
341 : 0 : return cache->buffer + offset;
342 : : }
343 : : }
344 : : }
345 : :
346 : 0 : return NULL;
347 : : }
348 : :
349 : : static int
350 : 0 : cache_glob_lookup_literal (const char *file_name,
351 : : const char *mime_types[],
352 : : int n_mime_types)
353 : : {
354 : : const char *ptr;
355 : : int i, min, max, mid, cmp;
356 : :
357 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
358 : : {
359 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
360 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
361 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
362 : : xdg_uint32_t offset;
363 : :
364 : 0 : min = 0;
365 : 0 : max = n_entries - 1;
366 [ # # ]: 0 : while (max >= min)
367 : : {
368 : 0 : mid = (min + max) / 2;
369 : :
370 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
371 : 0 : ptr = cache->buffer + offset;
372 : 0 : cmp = strcmp (ptr, file_name);
373 : :
374 [ # # ]: 0 : if (cmp < 0)
375 : 0 : min = mid + 1;
376 [ # # ]: 0 : else if (cmp > 0)
377 : 0 : max = mid - 1;
378 : : else
379 : : {
380 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
381 : 0 : mime_types[0] = (const char *)(cache->buffer + offset);
382 : :
383 : 0 : return 1;
384 : : }
385 : : }
386 : : }
387 : :
388 : 0 : return 0;
389 : : }
390 : :
391 : : static int
392 : 0 : cache_glob_lookup_fnmatch (const char *file_name,
393 : : const char *mime_types[],
394 : : int n_mime_types)
395 : : {
396 : : const char *mime_type;
397 : : const char *ptr;
398 : :
399 : : int i, j, n;
400 : :
401 : 0 : n = 0;
402 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
403 : : {
404 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
405 : :
406 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
407 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
408 : :
409 [ # # ][ # # ]: 0 : for (j = 0; j < n_entries && n < n_mime_types; j++)
410 : : {
411 : 0 : xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
412 : 0 : xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
413 : 0 : ptr = cache->buffer + offset;
414 : 0 : mime_type = cache->buffer + mimetype_offset;
415 : :
416 : : /* FIXME: Not UTF-8 safe */
417 [ # # ]: 0 : if (fnmatch (ptr, file_name, 0) == 0)
418 : 0 : mime_types[n++] = mime_type;
419 : : }
420 : :
421 [ # # ]: 0 : if (n > 0)
422 : 0 : return n;
423 : : }
424 : :
425 : 0 : return 0;
426 : : }
427 : :
428 : : static int
429 : 0 : cache_glob_node_lookup_suffix (XdgMimeCache *cache,
430 : : xdg_uint32_t n_entries,
431 : : xdg_uint32_t offset,
432 : : const char *suffix,
433 : : int ignore_case,
434 : : const char *mime_types[],
435 : : int n_mime_types)
436 : : {
437 : : xdg_unichar_t character;
438 : : xdg_unichar_t match_char;
439 : : xdg_uint32_t mimetype_offset;
440 : : xdg_uint32_t n_children;
441 : : xdg_uint32_t child_offset;
442 : :
443 : : int min, max, mid, n, i;
444 : :
445 : 0 : character = _xdg_utf8_to_ucs4 (suffix);
446 [ # # ]: 0 : if (ignore_case)
447 : 0 : character = _xdg_ucs4_to_lower (character);
448 : :
449 : 0 : min = 0;
450 : 0 : max = n_entries - 1;
451 [ # # ]: 0 : while (max >= min)
452 : : {
453 : 0 : mid = (min + max) / 2;
454 : :
455 : 0 : match_char = GET_UINT32 (cache->buffer, offset + 16 * mid);
456 : :
457 [ # # ]: 0 : if (match_char < character)
458 : 0 : min = mid + 1;
459 [ # # ]: 0 : else if (match_char > character)
460 : 0 : max = mid - 1;
461 : : else
462 : : {
463 : 0 : suffix = _xdg_utf8_next_char (suffix);
464 [ # # ]: 0 : if (*suffix == '\0')
465 : : {
466 : 0 : mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 4);
467 : 0 : n = 0;
468 [ # # ]: 0 : if (cache->buffer[mimetype_offset])
469 : 0 : mime_types[n++] = cache->buffer + mimetype_offset;
470 : :
471 : 0 : n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
472 : 0 : child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
473 : 0 : i = 0;
474 [ # # ][ # # ]: 0 : while (n < n_mime_types && i < n_children)
475 : : {
476 : 0 : match_char = GET_UINT32 (cache->buffer, child_offset + 16 * i);
477 : 0 : mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * i + 4);
478 [ # # ]: 0 : if (match_char != 0)
479 : 0 : break;
480 : :
481 : 0 : mime_types[n++] = cache->buffer + mimetype_offset;
482 : 0 : i++;
483 : : }
484 : :
485 : 0 : return n;
486 : : }
487 : : else
488 : : {
489 : 0 : n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
490 : 0 : child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
491 : :
492 : 0 : return cache_glob_node_lookup_suffix (cache,
493 : : n_children, child_offset,
494 : : suffix, ignore_case,
495 : : mime_types,
496 : : n_mime_types);
497 : : }
498 : : }
499 : : }
500 : :
501 : 0 : return 0;
502 : : }
503 : :
504 : : static int
505 : 0 : cache_glob_lookup_suffix (const char *suffix,
506 : : int ignore_case,
507 : : const char *mime_types[],
508 : : int n_mime_types)
509 : : {
510 : : int i, n;
511 : :
512 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
513 : : {
514 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
515 : :
516 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
517 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
518 : 0 : xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
519 : :
520 : 0 : n = cache_glob_node_lookup_suffix (cache,
521 : : n_entries, offset,
522 : : suffix, ignore_case,
523 : : mime_types,
524 : : n_mime_types);
525 [ # # ]: 0 : if (n > 0)
526 : 0 : return n;
527 : : }
528 : :
529 : 0 : return 0;
530 : : }
531 : :
532 : : static void
533 : 0 : find_stopchars (char *stopchars)
534 : : {
535 : : int i, j, k, l;
536 : :
537 : 0 : k = 0;
538 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
539 : : {
540 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
541 : :
542 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
543 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
544 : 0 : xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
545 : :
546 [ # # ]: 0 : for (j = 0; j < n_entries; j++)
547 : : {
548 : 0 : xdg_uint32_t match_char = GET_UINT32 (cache->buffer, offset);
549 : :
550 [ # # ]: 0 : if (match_char < 128)
551 : : {
552 [ # # ]: 0 : for (l = 0; l < k; l++)
553 [ # # ]: 0 : if (stopchars[l] == match_char)
554 : 0 : break;
555 [ # # ]: 0 : if (l == k)
556 : : {
557 : 0 : stopchars[k] = (char) match_char;
558 : 0 : k++;
559 : : }
560 : : }
561 : :
562 : 0 : offset += 16;
563 : : }
564 : : }
565 : :
566 : 0 : stopchars[k] = '\0';
567 : 0 : }
568 : :
569 : : static int
570 : 0 : cache_glob_lookup_file_name (const char *file_name,
571 : : const char *mime_types[],
572 : : int n_mime_types)
573 : : {
574 : : const char *ptr;
575 : : char stopchars[128];
576 : : int n;
577 : :
578 [ # # ]: 0 : assert (file_name != NULL);
579 : :
580 : : /* First, check the literals */
581 : 0 : n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types);
582 [ # # ]: 0 : if (n > 0)
583 : 0 : return n;
584 : :
585 : 0 : find_stopchars (stopchars);
586 : :
587 : : /* Next, check suffixes */
588 : 0 : ptr = strpbrk (file_name, stopchars);
589 [ # # ]: 0 : while (ptr)
590 : : {
591 : 0 : n = cache_glob_lookup_suffix (ptr, FALSE, mime_types, n_mime_types);
592 [ # # ]: 0 : if (n > 0)
593 : 0 : return n;
594 : :
595 : 0 : n = cache_glob_lookup_suffix (ptr, TRUE, mime_types, n_mime_types);
596 [ # # ]: 0 : if (n > 0)
597 : 0 : return n;
598 : :
599 : 0 : ptr = strpbrk (ptr + 1, stopchars);
600 : : }
601 : :
602 : : /* Last, try fnmatch */
603 : 0 : return cache_glob_lookup_fnmatch (file_name, mime_types, n_mime_types);
604 : : }
605 : :
606 : : int
607 : 0 : _xdg_mime_cache_get_max_buffer_extents (void)
608 : : {
609 : : xdg_uint32_t offset;
610 : : xdg_uint32_t max_extent;
611 : : int i;
612 : :
613 : 0 : max_extent = 0;
614 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
615 : : {
616 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
617 : :
618 : 0 : offset = GET_UINT32 (cache->buffer, 24);
619 : 0 : max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
620 : : }
621 : :
622 : 0 : return max_extent;
623 : : }
624 : :
625 : : static const char *
626 : 0 : cache_get_mime_type_for_data (const void *data,
627 : : size_t len,
628 : : const char *mime_types[],
629 : : int n_mime_types)
630 : : {
631 : : const char *mime_type;
632 : : int i, n, priority;
633 : :
634 : 0 : priority = 0;
635 : 0 : mime_type = NULL;
636 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
637 : : {
638 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
639 : :
640 : : int prio;
641 : : const char *match;
642 : :
643 : 0 : match = cache_magic_lookup_data (cache, data, len, &prio,
644 : : mime_types, n_mime_types);
645 [ # # ]: 0 : if (prio > priority)
646 : : {
647 : 0 : priority = prio;
648 : 0 : mime_type = match;
649 : : }
650 : : }
651 : :
652 [ # # ]: 0 : if (priority > 0)
653 : 0 : return mime_type;
654 : :
655 [ # # ]: 0 : for (n = 0; n < n_mime_types; n++)
656 : : {
657 [ # # ]: 0 : if (mime_types[n])
658 : 0 : return mime_types[n];
659 : : }
660 : :
661 : 0 : return XDG_MIME_TYPE_UNKNOWN;
662 : : }
663 : :
664 : : const char *
665 : 0 : _xdg_mime_cache_get_mime_type_for_data (const void *data,
666 : : size_t len)
667 : : {
668 : 0 : return cache_get_mime_type_for_data (data, len, NULL, 0);
669 : : }
670 : :
671 : : const char *
672 : 0 : _xdg_mime_cache_get_mime_type_for_file (const char *file_name,
673 : : struct stat *statbuf)
674 : : {
675 : : const char *mime_type;
676 : : const char *mime_types[2];
677 : : FILE *file;
678 : : unsigned char *data;
679 : : int max_extent;
680 : : int bytes_read;
681 : : struct stat buf;
682 : : const char *base_name;
683 : : int n;
684 : :
685 [ # # ]: 0 : if (file_name == NULL)
686 : 0 : return NULL;
687 : :
688 [ # # ]: 0 : if (! _xdg_utf8_validate (file_name))
689 : 0 : return NULL;
690 : :
691 : 0 : base_name = _xdg_get_base_name (file_name);
692 : 0 : n = cache_glob_lookup_file_name (base_name, mime_types, 2);
693 : :
694 [ # # ]: 0 : if (n == 1)
695 : 0 : return mime_types[0];
696 : :
697 [ # # ]: 0 : if (!statbuf)
698 : : {
699 [ # # ]: 0 : if (stat (file_name, &buf) != 0)
700 : 0 : return XDG_MIME_TYPE_UNKNOWN;
701 : :
702 : 0 : statbuf = &buf;
703 : : }
704 : :
705 [ # # ]: 0 : if (!S_ISREG (statbuf->st_mode))
706 : 0 : return XDG_MIME_TYPE_UNKNOWN;
707 : :
708 : : /* FIXME: Need to make sure that max_extent isn't totally broken. This could
709 : : * be large and need getting from a stream instead of just reading it all
710 : : * in. */
711 : 0 : max_extent = _xdg_mime_cache_get_max_buffer_extents ();
712 : 0 : data = malloc (max_extent);
713 [ # # ]: 0 : if (data == NULL)
714 : 0 : return XDG_MIME_TYPE_UNKNOWN;
715 : :
716 : 0 : file = fopen (file_name, "r");
717 [ # # ]: 0 : if (file == NULL)
718 : : {
719 : 0 : free (data);
720 : 0 : return XDG_MIME_TYPE_UNKNOWN;
721 : : }
722 : :
723 : 0 : bytes_read = fread (data, 1, max_extent, file);
724 [ # # ]: 0 : if (ferror (file))
725 : : {
726 : 0 : free (data);
727 : 0 : fclose (file);
728 : 0 : return XDG_MIME_TYPE_UNKNOWN;
729 : : }
730 : :
731 : 0 : mime_type = cache_get_mime_type_for_data (data, bytes_read,
732 : : mime_types, n);
733 : :
734 : 0 : free (data);
735 : 0 : fclose (file);
736 : :
737 : 0 : return mime_type;
738 : : }
739 : :
740 : : const char *
741 : 0 : _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
742 : : {
743 : : const char *mime_types[2];
744 : :
745 [ # # ]: 0 : if (cache_glob_lookup_file_name (file_name, mime_types, 2) == 1)
746 : 0 : return mime_types[0];
747 : : else
748 : 0 : return XDG_MIME_TYPE_UNKNOWN;
749 : : }
750 : :
751 : : #if 1
752 : : static int
753 : 0 : is_super_type (const char *mime)
754 : : {
755 : : int length;
756 : : const char *type;
757 : :
758 : 0 : length = strlen (mime);
759 : 0 : type = &(mime[length - 2]);
760 : :
761 [ # # ]: 0 : if (strcmp (type, "/*") == 0)
762 : 0 : return 1;
763 : :
764 : 0 : return 0;
765 : : }
766 : : #endif
767 : :
768 : : int
769 : 0 : _xdg_mime_cache_mime_type_subclass (const char *mime,
770 : : const char *base)
771 : : {
772 : : const char *umime, *ubase;
773 : :
774 : : int i, j, min, max, med, cmp;
775 : :
776 : 0 : umime = _xdg_mime_cache_unalias_mime_type (mime);
777 : 0 : ubase = _xdg_mime_cache_unalias_mime_type (base);
778 : :
779 [ # # ]: 0 : if (strcmp (umime, ubase) == 0)
780 : 0 : return 1;
781 : :
782 : : /* We really want to handle text/ * in GtkFileFilter, so we just
783 : : * turn on the supertype matching
784 : : */
785 : : #if 1
786 : : /* Handle supertypes */
787 [ # # # # ]: 0 : if (is_super_type (ubase) &&
788 : 0 : xdg_mime_media_type_equal (umime, ubase))
789 : 0 : return 1;
790 : : #endif
791 : :
792 : : /* Handle special cases text/plain and application/octet-stream */
793 [ # # ][ # # ]: 0 : if (strcmp (ubase, "text/plain") == 0 &&
794 : 0 : strncmp (umime, "text/", 5) == 0)
795 : 0 : return 1;
796 : :
797 [ # # ]: 0 : if (strcmp (ubase, "application/octet-stream") == 0)
798 : 0 : return 1;
799 : :
800 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
801 : : {
802 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
803 : :
804 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
805 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
806 : : xdg_uint32_t offset, n_parents, parent_offset;
807 : :
808 : 0 : min = 0;
809 : 0 : max = n_entries - 1;
810 [ # # ]: 0 : while (max >= min)
811 : : {
812 : 0 : med = (min + max)/2;
813 : :
814 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
815 : 0 : cmp = strcmp (cache->buffer + offset, umime);
816 [ # # ]: 0 : if (cmp < 0)
817 : 0 : min = med + 1;
818 [ # # ]: 0 : else if (cmp > 0)
819 : 0 : max = med - 1;
820 : : else
821 : : {
822 : 0 : offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
823 : 0 : n_parents = GET_UINT32 (cache->buffer, offset);
824 : :
825 [ # # ]: 0 : for (j = 0; j < n_parents; j++)
826 : : {
827 : 0 : parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
828 [ # # ]: 0 : if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
829 : 0 : return 1;
830 : : }
831 : :
832 : 0 : break;
833 : : }
834 : : }
835 : : }
836 : :
837 : 0 : return 0;
838 : : }
839 : :
840 : : const char *
841 : 0 : _xdg_mime_cache_unalias_mime_type (const char *mime)
842 : : {
843 : : const char *lookup;
844 : :
845 : 0 : lookup = cache_alias_lookup (mime);
846 : :
847 [ # # ]: 0 : if (lookup)
848 : 0 : return lookup;
849 : :
850 : 0 : return mime;
851 : : }
852 : :
853 : : char **
854 : 0 : _xdg_mime_cache_list_mime_parents (const char *mime)
855 : : {
856 : : int i, j, p;
857 : : char *all_parents[128]; /* we'll stop at 128 */
858 : : char **result;
859 : :
860 : 0 : mime = xdg_mime_unalias_mime_type (mime);
861 : :
862 : 0 : p = 0;
863 [ # # ]: 0 : for (i = 0; _xdg_mime_caches[i]; i++)
864 : : {
865 : 0 : XdgMimeCache *cache = _xdg_mime_caches[i];
866 : :
867 : 0 : xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
868 : 0 : xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
869 : :
870 [ # # ]: 0 : for (j = 0; j < n_entries; j++)
871 : : {
872 : 0 : xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
873 : 0 : xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
874 : :
875 [ # # ]: 0 : if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
876 : : {
877 : : int k;
878 : : xdg_uint32_t parent_mime_offset;
879 : 0 : xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
880 : :
881 [ # # ][ # # ]: 0 : for (k = 0; k < n_parents && p < 127; k++)
882 : : {
883 : 0 : parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
884 : 0 : all_parents[p++] = cache->buffer + parent_mime_offset;
885 : : }
886 : :
887 : 0 : break;
888 : : }
889 : : }
890 : : }
891 : 0 : all_parents[p++] = 0;
892 : :
893 : 0 : result = (char **) malloc (p * sizeof (char *));
894 : 0 : memcpy (result, all_parents, p * sizeof (char *));
895 : :
896 : 0 : return result;
897 : : }
898 : :
|
