nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* xdgmimemagic.: Private file. Datastructure for storing magic files.
3 *
4 * More info can be found at http://www.freedesktop.org/standards/
5 *
6 * Copyright (C) 2003 Red Hat, Inc.
7 * Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
8 *
9 * Licensed under the Academic Free License version 2.0
10 * Or under the following terms:
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
24 */
25  
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29  
30 #include <assert.h>
31 #include "xdgmimemagic.h"
32 #include "xdgmimeint.h"
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <limits.h>
39  
40 #ifndef FALSE
41 #define FALSE (0)
42 #endif
43  
44 #ifndef TRUE
45 #define TRUE (!FALSE)
46 #endif
47  
48 #if !defined getc_unlocked && !defined HAVE_GETC_UNLOCKED
49 # define getc_unlocked(fp) getc (fp)
50 #endif
51  
52 typedef struct XdgMimeMagicMatch XdgMimeMagicMatch;
53 typedef struct XdgMimeMagicMatchlet XdgMimeMagicMatchlet;
54  
55 typedef enum
56 {
57 XDG_MIME_MAGIC_SECTION,
58 XDG_MIME_MAGIC_MAGIC,
59 XDG_MIME_MAGIC_ERROR,
60 XDG_MIME_MAGIC_EOF
61 } XdgMimeMagicState;
62  
63 struct XdgMimeMagicMatch
64 {
65 const char *mime_type;
66 int priority;
67 XdgMimeMagicMatchlet *matchlet;
68 XdgMimeMagicMatch *next;
69 };
70  
71  
72 struct XdgMimeMagicMatchlet
73 {
74 int indent;
75 int offset;
76 unsigned int value_length;
77 unsigned char *value;
78 unsigned char *mask;
79 unsigned int range_length;
80 unsigned int word_size;
81 XdgMimeMagicMatchlet *next;
82 };
83  
84  
85 struct XdgMimeMagic
86 {
87 XdgMimeMagicMatch *match_list;
88 int max_extent;
89 };
90  
91 static XdgMimeMagicMatch *
92 _xdg_mime_magic_match_new (void)
93 {
94 return calloc (1, sizeof (XdgMimeMagicMatch));
95 }
96  
97  
98 static XdgMimeMagicMatchlet *
99 _xdg_mime_magic_matchlet_new (void)
100 {
101 XdgMimeMagicMatchlet *matchlet;
102  
103 matchlet = malloc (sizeof (XdgMimeMagicMatchlet));
104  
105 matchlet->indent = 0;
106 matchlet->offset = 0;
107 matchlet->value_length = 0;
108 matchlet->value = NULL;
109 matchlet->mask = NULL;
110 matchlet->range_length = 1;
111 matchlet->word_size = 1;
112 matchlet->next = NULL;
113  
114 return matchlet;
115 }
116  
117  
118 static void
119 _xdg_mime_magic_matchlet_free (XdgMimeMagicMatchlet *mime_magic_matchlet)
120 {
121 if (mime_magic_matchlet)
122 {
123 if (mime_magic_matchlet->next)
124 _xdg_mime_magic_matchlet_free (mime_magic_matchlet->next);
125 if (mime_magic_matchlet->value)
126 free (mime_magic_matchlet->value);
127 if (mime_magic_matchlet->mask)
128 free (mime_magic_matchlet->mask);
129 free (mime_magic_matchlet);
130 }
131 }
132  
133  
134 /* Frees mime_magic_match and the remainder of its list
135 */
136 static void
137 _xdg_mime_magic_match_free (XdgMimeMagicMatch *mime_magic_match)
138 {
139 XdgMimeMagicMatch *ptr, *next;
140  
141 ptr = mime_magic_match;
142 while (ptr)
143 {
144 next = ptr->next;
145  
146 if (ptr->mime_type)
147 free ((void *) ptr->mime_type);
148 if (ptr->matchlet)
149 _xdg_mime_magic_matchlet_free (ptr->matchlet);
150 free (ptr);
151  
152 ptr = next;
153 }
154 }
155  
156 /* Reads in a hunk of data until a newline character or a '\000' is hit. The
157 * returned string is null terminated, and doesn't include the newline.
158 */
159 static unsigned char *
160 _xdg_mime_magic_read_to_newline (FILE *magic_file,
161 int *end_of_file)
162 {
163 unsigned char *retval;
164 int c;
165 int len, pos;
166  
167 len = 128;
168 pos = 0;
169 retval = malloc (len);
170 *end_of_file = FALSE;
171  
172 while (TRUE)
173 {
174 c = getc_unlocked (magic_file);
175 if (c == EOF)
176 {
177 *end_of_file = TRUE;
178 break;
179 }
180 if (c == '\n' || c == '\000')
181 break;
182 retval[pos++] = (unsigned char) c;
183 if (pos % 128 == 127)
184 {
185 len = len + 128;
186 retval = realloc (retval, len);
187 }
188 }
189  
190 retval[pos] = '\000';
191 return retval;
192 }
193  
194 /* Returns the number read from the file, or -1 if no number could be read.
195 */
196 static int
197 _xdg_mime_magic_read_a_number (FILE *magic_file,
198 int *end_of_file)
199 {
200 /* LONG_MAX is about 20 characters on my system */
201 #define MAX_NUMBER_SIZE 30
202 char number_string[MAX_NUMBER_SIZE + 1];
203 int pos = 0;
204 int c;
205 long retval = -1;
206  
207 while (TRUE)
208 {
209 c = getc_unlocked (magic_file);
210  
211 if (c == EOF)
212 {
213 *end_of_file = TRUE;
214 break;
215 }
216 if (! isdigit (c))
217 {
218 ungetc (c, magic_file);
219 break;
220 }
221 number_string[pos] = (char) c;
222 pos++;
223 if (pos == MAX_NUMBER_SIZE)
224 break;
225 }
226 if (pos > 0)
227 {
228 number_string[pos] = '\000';
229 errno = 0;
230 retval = strtol (number_string, NULL, 10);
231  
232 if ((retval < INT_MIN) || (retval > INT_MAX) || (errno != 0))
233 return -1;
234 }
235  
236 return retval;
237 }
238  
239 /* Headers are of the format:
240 * [<priority>:<mime-type>]
241 */
242 static XdgMimeMagicState
243 _xdg_mime_magic_parse_header (FILE *magic_file, XdgMimeMagicMatch *match)
244 {
245 int c;
246 char *buffer;
247 char *end_ptr;
248 int end_of_file = 0;
249  
250 assert (magic_file != NULL);
251 assert (match != NULL);
252  
253 c = getc_unlocked (magic_file);
254 if (c == EOF)
255 return XDG_MIME_MAGIC_EOF;
256 if (c != '[')
257 return XDG_MIME_MAGIC_ERROR;
258  
259 match->priority = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
260 if (end_of_file)
261 return XDG_MIME_MAGIC_EOF;
262 if (match->priority == -1)
263 return XDG_MIME_MAGIC_ERROR;
264  
265 c = getc_unlocked (magic_file);
266 if (c == EOF)
267 return XDG_MIME_MAGIC_EOF;
268 if (c != ':')
269 return XDG_MIME_MAGIC_ERROR;
270  
271 buffer = (char *)_xdg_mime_magic_read_to_newline (magic_file, &end_of_file);
272 if (end_of_file)
273 {
274 free (buffer);
275 return XDG_MIME_MAGIC_EOF;
276 }
277  
278 end_ptr = buffer;
279 while (*end_ptr != ']' && *end_ptr != '\000' && *end_ptr != '\n')
280 end_ptr++;
281 if (*end_ptr != ']')
282 {
283 free (buffer);
284 return XDG_MIME_MAGIC_ERROR;
285 }
286 *end_ptr = '\000';
287  
288 match->mime_type = strdup (buffer);
289 free (buffer);
290  
291 return XDG_MIME_MAGIC_MAGIC;
292 }
293  
294 static XdgMimeMagicState
295 _xdg_mime_magic_parse_error (FILE *magic_file)
296 {
297 int c;
298  
299 while (1)
300 {
301 c = getc_unlocked (magic_file);
302 if (c == EOF)
303 return XDG_MIME_MAGIC_EOF;
304 if (c == '\n')
305 return XDG_MIME_MAGIC_SECTION;
306 }
307 }
308  
309 /* Headers are of the format:
310 * [ indent ] ">" start-offset "=" value
311 * [ "&" mask ] [ "~" word-size ] [ "+" range-length ] "\n"
312 */
313 static XdgMimeMagicState
314 _xdg_mime_magic_parse_magic_line (FILE *magic_file,
315 XdgMimeMagicMatch *match)
316 {
317 XdgMimeMagicMatchlet *matchlet;
318 int c;
319 int end_of_file;
320 int indent = 0;
321 int bytes_read;
322  
323 assert (magic_file != NULL);
324  
325 /* Sniff the buffer to make sure it's a valid line */
326 c = getc_unlocked (magic_file);
327 if (c == EOF)
328 return XDG_MIME_MAGIC_EOF;
329 else if (c == '[')
330 {
331 ungetc (c, magic_file);
332 return XDG_MIME_MAGIC_SECTION;
333 }
334 else if (c == '\n')
335 return XDG_MIME_MAGIC_MAGIC;
336  
337 /* At this point, it must be a digit or a '>' */
338 end_of_file = FALSE;
339 if (isdigit (c))
340 {
341 ungetc (c, magic_file);
342 indent = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
343 if (end_of_file)
344 return XDG_MIME_MAGIC_EOF;
345 if (indent == -1)
346 return XDG_MIME_MAGIC_ERROR;
347 c = getc_unlocked (magic_file);
348 if (c == EOF)
349 return XDG_MIME_MAGIC_EOF;
350 }
351  
352 if (c != '>')
353 return XDG_MIME_MAGIC_ERROR;
354  
355 matchlet = _xdg_mime_magic_matchlet_new ();
356 matchlet->indent = indent;
357 matchlet->offset = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
358 if (end_of_file)
359 {
360 _xdg_mime_magic_matchlet_free (matchlet);
361 return XDG_MIME_MAGIC_EOF;
362 }
363 if (matchlet->offset == -1)
364 {
365 _xdg_mime_magic_matchlet_free (matchlet);
366 return XDG_MIME_MAGIC_ERROR;
367 }
368 c = getc_unlocked (magic_file);
369 if (c == EOF)
370 {
371 _xdg_mime_magic_matchlet_free (matchlet);
372 return XDG_MIME_MAGIC_EOF;
373 }
374 else if (c != '=')
375 {
376 _xdg_mime_magic_matchlet_free (matchlet);
377 return XDG_MIME_MAGIC_ERROR;
378 }
379  
380 /* Next two bytes determine how long the value is */
381 matchlet->value_length = 0;
382 c = getc_unlocked (magic_file);
383 if (c == EOF)
384 {
385 _xdg_mime_magic_matchlet_free (matchlet);
386 return XDG_MIME_MAGIC_EOF;
387 }
388 matchlet->value_length = c & 0xFF;
389 matchlet->value_length = matchlet->value_length << 8;
390  
391 c = getc_unlocked (magic_file);
392 if (c == EOF)
393 {
394 _xdg_mime_magic_matchlet_free (matchlet);
395 return XDG_MIME_MAGIC_EOF;
396 }
397 matchlet->value_length = matchlet->value_length + (c & 0xFF);
398  
399 matchlet->value = malloc (matchlet->value_length);
400  
401 /* OOM */
402 if (matchlet->value == NULL)
403 {
404 _xdg_mime_magic_matchlet_free (matchlet);
405 return XDG_MIME_MAGIC_ERROR;
406 }
407 bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file);
408 if (bytes_read != matchlet->value_length)
409 {
410 _xdg_mime_magic_matchlet_free (matchlet);
411 if (feof (magic_file))
412 return XDG_MIME_MAGIC_EOF;
413 else
414 return XDG_MIME_MAGIC_ERROR;
415 }
416  
417 c = getc_unlocked (magic_file);
418 if (c == '&')
419 {
420 matchlet->mask = malloc (matchlet->value_length);
421 /* OOM */
422 if (matchlet->mask == NULL)
423 {
424 _xdg_mime_magic_matchlet_free (matchlet);
425 return XDG_MIME_MAGIC_ERROR;
426 }
427 bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file);
428 if (bytes_read != matchlet->value_length)
429 {
430 _xdg_mime_magic_matchlet_free (matchlet);
431 if (feof (magic_file))
432 return XDG_MIME_MAGIC_EOF;
433 else
434 return XDG_MIME_MAGIC_ERROR;
435 }
436 c = getc_unlocked (magic_file);
437 }
438  
439 if (c == '~')
440 {
441 matchlet->word_size = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
442 if (end_of_file)
443 {
444 _xdg_mime_magic_matchlet_free (matchlet);
445 return XDG_MIME_MAGIC_EOF;
446 }
447 if (matchlet->word_size != 0 &&
448 matchlet->word_size != 1 &&
449 matchlet->word_size != 2 &&
450 matchlet->word_size != 4)
451 {
452 _xdg_mime_magic_matchlet_free (matchlet);
453 return XDG_MIME_MAGIC_ERROR;
454 }
455 c = getc_unlocked (magic_file);
456 }
457  
458 if (c == '+')
459 {
460 matchlet->range_length = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
461 if (end_of_file)
462 {
463 _xdg_mime_magic_matchlet_free (matchlet);
464 return XDG_MIME_MAGIC_EOF;
465 }
466 if (matchlet->range_length == -1)
467 {
468 _xdg_mime_magic_matchlet_free (matchlet);
469 return XDG_MIME_MAGIC_ERROR;
470 }
471 c = getc_unlocked (magic_file);
472 }
473  
474  
475 if (c == '\n')
476 {
477 /* We clean up the matchlet, byte swapping if needed */
478 if (matchlet->word_size > 1)
479 {
480 #if LITTLE_ENDIAN
481 int i;
482 #endif
483 if (matchlet->value_length % matchlet->word_size != 0)
484 {
485 _xdg_mime_magic_matchlet_free (matchlet);
486 return XDG_MIME_MAGIC_ERROR;
487 }
488 /* FIXME: need to get this defined in a <config.h> style file */
489 #if LITTLE_ENDIAN
490 for (i = 0; i < matchlet->value_length; i = i + matchlet->word_size)
491 {
492 if (matchlet->word_size == 2)
493 *((xdg_uint16_t *) matchlet->value + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->value + i)));
494 else if (matchlet->word_size == 4)
495 *((xdg_uint32_t *) matchlet->value + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->value + i)));
496 if (matchlet->mask)
497 {
498 if (matchlet->word_size == 2)
499 *((xdg_uint16_t *) matchlet->mask + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->mask + i)));
500 else if (matchlet->word_size == 4)
501 *((xdg_uint32_t *) matchlet->mask + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->mask + i)));
502  
503 }
504 }
505 #endif
506 }
507  
508 matchlet->next = match->matchlet;
509 match->matchlet = matchlet;
510  
511  
512 return XDG_MIME_MAGIC_MAGIC;
513 }
514  
515 _xdg_mime_magic_matchlet_free (matchlet);
516 if (c == EOF)
517 return XDG_MIME_MAGIC_EOF;
518  
519 return XDG_MIME_MAGIC_ERROR;
520 }
521  
522 static int
523 _xdg_mime_magic_matchlet_compare_to_data (XdgMimeMagicMatchlet *matchlet,
524 const void *data,
525 size_t len)
526 {
527 int i, j;
528 for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++)
529 {
530 int valid_matchlet = TRUE;
531  
532 if (i + matchlet->value_length > len)
533 return FALSE;
534  
535 if (matchlet->mask)
536 {
537 for (j = 0; j < matchlet->value_length; j++)
538 {
539 if ((matchlet->value[j] & matchlet->mask[j]) !=
540 ((((unsigned char *) data)[j + i]) & matchlet->mask[j]))
541 {
542 valid_matchlet = FALSE;
543 break;
544 }
545 }
546 }
547 else
548 {
549 for (j = 0; j < matchlet->value_length; j++)
550 {
551 if (matchlet->value[j] != ((unsigned char *) data)[j + i])
552 {
553 valid_matchlet = FALSE;
554 break;
555 }
556 }
557 }
558 if (valid_matchlet)
559 return TRUE;
560 }
561 return FALSE;
562 }
563  
564 static int
565 _xdg_mime_magic_matchlet_compare_level (XdgMimeMagicMatchlet *matchlet,
566 const void *data,
567 size_t len,
568 int indent)
569 {
570 while ((matchlet != NULL) && (matchlet->indent == indent))
571 {
572 if (_xdg_mime_magic_matchlet_compare_to_data (matchlet, data, len))
573 {
574 if ((matchlet->next == NULL) ||
575 (matchlet->next->indent <= indent))
576 return TRUE;
577  
578 if (_xdg_mime_magic_matchlet_compare_level (matchlet->next,
579 data,
580 len,
581 indent + 1))
582 return TRUE;
583 }
584  
585 do
586 {
587 matchlet = matchlet->next;
588 }
589 while (matchlet && matchlet->indent > indent);
590 }
591  
592 return FALSE;
593 }
594  
595 static int
596 _xdg_mime_magic_match_compare_to_data (XdgMimeMagicMatch *match,
597 const void *data,
598 size_t len)
599 {
600 return _xdg_mime_magic_matchlet_compare_level (match->matchlet, data, len, 0);
601 }
602  
603 static void
604 _xdg_mime_magic_insert_match (XdgMimeMagic *mime_magic,
605 XdgMimeMagicMatch *match)
606 {
607 XdgMimeMagicMatch *list;
608  
609 if (mime_magic->match_list == NULL)
610 {
611 mime_magic->match_list = match;
612 return;
613 }
614  
615 if (match->priority > mime_magic->match_list->priority)
616 {
617 match->next = mime_magic->match_list;
618 mime_magic->match_list = match;
619 return;
620 }
621  
622 list = mime_magic->match_list;
623 while (list->next != NULL)
624 {
625 if (list->next->priority < match->priority)
626 {
627 match->next = list->next;
628 list->next = match;
629 return;
630 }
631 list = list->next;
632 }
633 list->next = match;
634 match->next = NULL;
635 }
636  
637 XdgMimeMagic *
638 _xdg_mime_magic_new (void)
639 {
640 return calloc (1, sizeof (XdgMimeMagic));
641 }
642  
643 void
644 _xdg_mime_magic_free (XdgMimeMagic *mime_magic)
645 {
646 if (mime_magic) {
647 _xdg_mime_magic_match_free (mime_magic->match_list);
648 free (mime_magic);
649 }
650 }
651  
652 int
653 _xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic)
654 {
655 return mime_magic->max_extent;
656 }
657  
658 const char *
659 _xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
660 const void *data,
661 size_t len,
662 int *result_prio,
663 const char *mime_types[],
664 int n_mime_types)
665 {
666 XdgMimeMagicMatch *match;
667 const char *mime_type;
668 int n;
669 int prio;
670  
671 prio = 0;
672 mime_type = NULL;
673 for (match = mime_magic->match_list; match; match = match->next)
674 {
675 if (_xdg_mime_magic_match_compare_to_data (match, data, len))
676 {
677 prio = match->priority;
678 mime_type = match->mime_type;
679 break;
680 }
681 else
682 {
683 for (n = 0; n < n_mime_types; n++)
684 {
685 if (mime_types[n] &&
686 _xdg_mime_mime_type_equal (mime_types[n], match->mime_type))
687 mime_types[n] = NULL;
688 }
689 }
690 }
691  
692 if (mime_type == NULL)
693 {
694 for (n = 0; n < n_mime_types; n++)
695 {
696 if (mime_types[n])
697 mime_type = mime_types[n];
698 }
699 }
700  
701 if (result_prio)
702 *result_prio = prio;
703  
704 return mime_type;
705 }
706  
707 static void
708 _xdg_mime_update_mime_magic_extents (XdgMimeMagic *mime_magic)
709 {
710 XdgMimeMagicMatch *match;
711 int max_extent = 0;
712  
713 for (match = mime_magic->match_list; match; match = match->next)
714 {
715 XdgMimeMagicMatchlet *matchlet;
716  
717 for (matchlet = match->matchlet; matchlet; matchlet = matchlet->next)
718 {
719 int extent;
720  
721 extent = matchlet->value_length + matchlet->offset + matchlet->range_length;
722 if (max_extent < extent)
723 max_extent = extent;
724 }
725 }
726  
727 mime_magic->max_extent = max_extent;
728 }
729  
730 static XdgMimeMagicMatchlet *
731 _xdg_mime_magic_matchlet_mirror (XdgMimeMagicMatchlet *matchlets)
732 {
733 XdgMimeMagicMatchlet *new_list;
734 XdgMimeMagicMatchlet *tmp;
735  
736 if ((matchlets == NULL) || (matchlets->next == NULL))
737 return matchlets;
738  
739 new_list = NULL;
740 tmp = matchlets;
741 while (tmp != NULL)
742 {
743 XdgMimeMagicMatchlet *matchlet;
744  
745 matchlet = tmp;
746 tmp = tmp->next;
747 matchlet->next = new_list;
748 new_list = matchlet;
749 }
750  
751 return new_list;
752  
753 }
754  
755 static void
756 _xdg_mime_magic_read_magic_file (XdgMimeMagic *mime_magic,
757 FILE *magic_file)
758 {
759 XdgMimeMagicState state;
760 XdgMimeMagicMatch *match = NULL; /* Quiet compiler */
761  
762 state = XDG_MIME_MAGIC_SECTION;
763  
764 while (state != XDG_MIME_MAGIC_EOF)
765 {
766 switch (state)
767 {
768 case XDG_MIME_MAGIC_SECTION:
769 match = _xdg_mime_magic_match_new ();
770 state = _xdg_mime_magic_parse_header (magic_file, match);
771 if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
772 _xdg_mime_magic_match_free (match);
773 break;
774 case XDG_MIME_MAGIC_MAGIC:
775 state = _xdg_mime_magic_parse_magic_line (magic_file, match);
776 if (state == XDG_MIME_MAGIC_SECTION ||
777 (state == XDG_MIME_MAGIC_EOF && match->mime_type))
778 {
779 match->matchlet = _xdg_mime_magic_matchlet_mirror (match->matchlet);
780 _xdg_mime_magic_insert_match (mime_magic, match);
781 }
782 else if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
783 _xdg_mime_magic_match_free (match);
784 break;
785 case XDG_MIME_MAGIC_ERROR:
786 state = _xdg_mime_magic_parse_error (magic_file);
787 break;
788 case XDG_MIME_MAGIC_EOF:
789 default:
790 /* Make the compiler happy */
791 assert (0);
792 }
793 }
794 _xdg_mime_update_mime_magic_extents (mime_magic);
795 }
796  
797 void
798 _xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
799 const char *file_name)
800 {
801 FILE *magic_file;
802 char header[12];
803  
804 magic_file = fopen (file_name, "r");
805  
806 if (magic_file == NULL)
807 return;
808  
809 if (fread (header, 1, 12, magic_file) == 12)
810 {
811 if (memcmp ("MIME-Magic\0\n", header, 12) == 0)
812 _xdg_mime_magic_read_magic_file (mime_magic, magic_file);
813 }
814  
815 fclose (magic_file);
816 }