gio/xdgmime/xdgmimemagic.c

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