glue/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 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, write to the
  24  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25  * Boston, MA 02111-1307, USA.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31
  32 #include <assert.h>
  33 #include "xdgmimemagic.h"
  34 #include "xdgmimeint.h"
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include <errno.h>
  40 #include <limits.h>
  41
  42 #ifndef FALSE
  43 #define FALSE   (0)
  44 #endif
  45
  46 #ifndef TRUE
  47 #define TRUE    (!FALSE)
  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     return XDG_MIME_MAGIC_EOF;
 272
 273   end_ptr = buffer;
 274   while (*end_ptr != ']' && *end_ptr != '\000' && *end_ptr != '\n')
 275     end_ptr++;
 276   if (*end_ptr != ']')
 277     {
 278       free (buffer);
 279       return XDG_MIME_MAGIC_ERROR;
 280     }
 281   *end_ptr = '\000';
 282
 283   match->mime_type = strdup (buffer);
 284   free (buffer);
 285
 286   return XDG_MIME_MAGIC_MAGIC;
 287 }
 288
 289 static XdgMimeMagicState
 290 _xdg_mime_magic_parse_error (FILE *magic_file)
 291 {
 292   int c;
 293
 294   while (1)
 295     {
 296       c = getc_unlocked (magic_file);
 297       if (c == EOF)
 298         return XDG_MIME_MAGIC_EOF;
 299       if (c == '\n')
 300         return XDG_MIME_MAGIC_SECTION;
 301     }
 302 }
 303
 304 /* Headers are of the format:
 305  * [ indent ] ">" start-offset "=" value
 306  * [ "&" mask ] [ "~" word-size ] [ "+" range-length ] "\n"
 307  */
 308 static XdgMimeMagicState
 309 _xdg_mime_magic_parse_magic_line (FILE              *magic_file,
 310                                   XdgMimeMagicMatch *match)
 311 {
 312   XdgMimeMagicMatchlet *matchlet;
 313   int c;
 314   int end_of_file;
 315   int indent = 0;
 316   int bytes_read;
 317
 318   assert (magic_file != NULL);
 319
 320   /* Sniff the buffer to make sure it's a valid line */
 321   c = getc_unlocked (magic_file);
 322   if (c == EOF)
 323     return XDG_MIME_MAGIC_EOF;
 324   else if (c == '[')
 325     {
 326       ungetc (c, magic_file);
 327       return XDG_MIME_MAGIC_SECTION;
 328     }
 329   else if (c == '\n')
 330     return XDG_MIME_MAGIC_MAGIC;
 331
 332   /* At this point, it must be a digit or a '>' */
 333   end_of_file = FALSE;
 334   if (isdigit (c))
 335     {
 336       ungetc (c, magic_file);
 337       indent = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
 338       if (end_of_file)
 339         return XDG_MIME_MAGIC_EOF;
 340       if (indent == -1)
 341         return XDG_MIME_MAGIC_ERROR;
 342       c = getc_unlocked (magic_file);
 343       if (c == EOF)
 344         return XDG_MIME_MAGIC_EOF;
 345     }
 346
 347   if (c != '>')
 348     return XDG_MIME_MAGIC_ERROR;
 349
 350   matchlet = _xdg_mime_magic_matchlet_new ();
 351   matchlet->indent = indent;
 352   matchlet->offset = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
 353   if (end_of_file)
 354     {
 355       _xdg_mime_magic_matchlet_free (matchlet);
 356       return XDG_MIME_MAGIC_EOF;
 357     }
 358   if (matchlet->offset == -1)
 359     {
 360       _xdg_mime_magic_matchlet_free (matchlet);
 361       return XDG_MIME_MAGIC_ERROR;
 362     }
 363   c = getc_unlocked (magic_file);
 364   if (c == EOF)
 365     {
 366       _xdg_mime_magic_matchlet_free (matchlet);
 367       return XDG_MIME_MAGIC_EOF;
 368     }
 369   else if (c != '=')
 370     {
 371       _xdg_mime_magic_matchlet_free (matchlet);
 372       return XDG_MIME_MAGIC_ERROR;
 373     }
 374
 375   /* Next two bytes determine how long the value is */
 376   matchlet->value_length = 0;
 377   c = getc_unlocked (magic_file);
 378   if (c == EOF)
 379     {
 380       _xdg_mime_magic_matchlet_free (matchlet);
 381       return XDG_MIME_MAGIC_EOF;
 382     }
 383   matchlet->value_length = c & 0xFF;
 384   matchlet->value_length = matchlet->value_length << 8;
 385
 386   c = getc_unlocked (magic_file);
 387   if (c == EOF)
 388     {
 389       _xdg_mime_magic_matchlet_free (matchlet);
 390       return XDG_MIME_MAGIC_EOF;
 391     }
 392   matchlet->value_length = matchlet->value_length + (c & 0xFF);
 393
 394   matchlet->value = malloc (matchlet->value_length);
 395
 396   /* OOM */
 397   if (matchlet->value == NULL)
 398     {
 399       _xdg_mime_magic_matchlet_free (matchlet);
 400       return XDG_MIME_MAGIC_ERROR;
 401     }
 402   bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file);
 403   if (bytes_read != matchlet->value_length)
 404     {
 405       _xdg_mime_magic_matchlet_free (matchlet);
 406       if (feof (magic_file))
 407         return XDG_MIME_MAGIC_EOF;
 408       else
 409         return XDG_MIME_MAGIC_ERROR;
 410     }
 411
 412   c = getc_unlocked (magic_file);
 413   if (c == '&')
 414     {
 415       matchlet->mask = malloc (matchlet->value_length);
 416       /* OOM */
 417       if (matchlet->mask == NULL)
 418         {
 419           _xdg_mime_magic_matchlet_free (matchlet);
 420           return XDG_MIME_MAGIC_ERROR;
 421         }
 422       bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file);
 423       if (bytes_read != matchlet->value_length)
 424         {
 425           _xdg_mime_magic_matchlet_free (matchlet);
 426           if (feof (magic_file))
 427             return XDG_MIME_MAGIC_EOF;
 428           else
 429             return XDG_MIME_MAGIC_ERROR;
 430         }
 431       c = getc_unlocked (magic_file);
 432     }
 433
 434   if (c == '~')
 435     {
 436       matchlet->word_size = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
 437       if (end_of_file)
 438         {
 439           _xdg_mime_magic_matchlet_free (matchlet);
 440           return XDG_MIME_MAGIC_EOF;
 441         }
 442       if (matchlet->word_size != 0 &&
 443           matchlet->word_size != 1 &&
 444           matchlet->word_size != 2 &&
 445           matchlet->word_size != 4)
 446         {
 447           _xdg_mime_magic_matchlet_free (matchlet);
 448           return XDG_MIME_MAGIC_ERROR;
 449         }
 450       c = getc_unlocked (magic_file);
 451     }
 452
 453   if (c == '+')
 454     {
 455       matchlet->range_length = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
 456       if (end_of_file)
 457         {
 458           _xdg_mime_magic_matchlet_free (matchlet);
 459           return XDG_MIME_MAGIC_EOF;
 460         }
 461       if (matchlet->range_length == -1)
 462         {
 463           _xdg_mime_magic_matchlet_free (matchlet);
 464           return XDG_MIME_MAGIC_ERROR;
 465         }
 466       c = getc_unlocked (magic_file);
 467     }
 468
 469
 470   if (c == '\n')
 471     {
 472       /* We clean up the matchlet, byte swapping if needed */
 473       if (matchlet->word_size > 1)
 474         {
 475           int i;
 476           if (matchlet->value_length % matchlet->word_size != 0)
 477             {
 478               _xdg_mime_magic_matchlet_free (matchlet);
 479               return XDG_MIME_MAGIC_ERROR;
 480             }
 481           /* FIXME: need to get this defined in a <config.h> style file */
 482 #if LITTLE_ENDIAN
 483           for (i = 0; i < matchlet->value_length; i = i + matchlet->word_size)
 484             {
 485               if (matchlet->word_size == 2)
 486                 *((xdg_uint16_t *) matchlet->value + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->value + i)));
 487               else if (matchlet->word_size == 4)
 488                 *((xdg_uint32_t *) matchlet->value + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->value + i)));
 489               if (matchlet->mask)
 490                 {
 491                   if (matchlet->word_size == 2)
 492                     *((xdg_uint16_t *) matchlet->mask + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->mask + i)));
 493                   else if (matchlet->word_size == 4)
 494                     *((xdg_uint32_t *) matchlet->mask + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->mask + i)));
 495
 496                 }
 497             }
 498 #endif
 499         }
 500
 501       matchlet->next = match->matchlet;
 502       match->matchlet = matchlet;
 503
 504
 505       return XDG_MIME_MAGIC_MAGIC;
 506     }
 507
 508   _xdg_mime_magic_matchlet_free (matchlet);
 509   if (c == EOF)
 510     return XDG_MIME_MAGIC_EOF;
 511
 512   return XDG_MIME_MAGIC_ERROR;
 513 }
 514
 515 static int
 516 _xdg_mime_magic_matchlet_compare_to_data (XdgMimeMagicMatchlet *matchlet,
 517                                           const void           *data,
 518                                           size_t                len)
 519 {
 520   int i, j;
 521   for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++)
 522     {
 523       int valid_matchlet = TRUE;
 524
 525       if (i + matchlet->value_length > len)
 526         return FALSE;
 527
 528       if (matchlet->mask)
 529         {
 530           for (j = 0; j < matchlet->value_length; j++)
 531             {
 532               if ((matchlet->value[j] & matchlet->mask[j]) !=
 533                   ((((unsigned char *) data)[j + i]) & matchlet->mask[j]))
 534                 {
 535                   valid_matchlet = FALSE;
 536                   break;
 537                 }
 538             }
 539         }
 540       else
 541         {
 542           for (j = 0; j <  matchlet->value_length; j++)
 543             {
 544               if (matchlet->value[j] != ((unsigned char *) data)[j + i])
 545                 {
 546                   valid_matchlet = FALSE;
 547                   break;
 548                 }
 549             }
 550         }
 551       if (valid_matchlet)
 552         return TRUE;
 553     }
 554   return FALSE;
 555 }
 556
 557 static int
 558 _xdg_mime_magic_matchlet_compare_level (XdgMimeMagicMatchlet *matchlet,
 559                                         const void           *data,
 560                                         size_t                len,
 561                                         int                   indent)
 562 {
 563   while ((matchlet != NULL) && (matchlet->indent == indent))
 564     {
 565       if (_xdg_mime_magic_matchlet_compare_to_data (matchlet, data, len))
 566         {
 567           if ((matchlet->next == NULL) ||
 568               (matchlet->next->indent <= indent))
 569             return TRUE;
 570
 571           if (_xdg_mime_magic_matchlet_compare_level (matchlet->next,
 572                                                       data,
 573                                                       len,
 574                                                       indent + 1))
 575             return TRUE;
 576         }
 577
 578       do
 579         {
 580           matchlet = matchlet->next;
 581         }
 582       while (matchlet && matchlet->indent > indent);
 583     }
 584
 585   return FALSE;
 586 }
 587
 588 static int
 589 _xdg_mime_magic_match_compare_to_data (XdgMimeMagicMatch *match,
 590                                        const void        *data,
 591                                        size_t             len)
 592 {
 593   return _xdg_mime_magic_matchlet_compare_level (match->matchlet, data, len, 0);
 594 }
 595
 596 static void
 597 _xdg_mime_magic_insert_match (XdgMimeMagic      *mime_magic,
 598                               XdgMimeMagicMatch *match)
 599 {
 600   XdgMimeMagicMatch *list;
 601
 602   if (mime_magic->match_list == NULL)
 603     {
 604       mime_magic->match_list = match;
 605       return;
 606     }
 607
 608   if (match->priority > mime_magic->match_list->priority)
 609     {
 610       match->next = mime_magic->match_list;
 611       mime_magic->match_list = match;
 612       return;
 613     }
 614
 615   list = mime_magic->match_list;
 616   while (list->next != NULL)
 617     {
 618       if (list->next->priority < match->priority)
 619         {
 620           match->next = list->next;
 621           list->next = match;
 622           return;
 623         }
 624       list = list->next;
 625     }
 626   list->next = match;
 627   match->next = NULL;
 628 }
 629
 630 XdgMimeMagic *
 631 _xdg_mime_magic_new (void)
 632 {
 633   return calloc (1, sizeof (XdgMimeMagic));
 634 }
 635
 636 void
 637 _xdg_mime_magic_free (XdgMimeMagic *mime_magic)
 638 {
 639   if (mime_magic) {
 640     _xdg_mime_magic_match_free (mime_magic->match_list);
 641     free (mime_magic);
 642   }
 643 }
 644
 645 int
 646 _xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic)
 647 {
 648   return mime_magic->max_extent;
 649 }
 650
 651 const char *
 652 _xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
 653                              const void   *data,
 654                              size_t        len,
 655                              const char   *mime_types[],
 656                              int           n_mime_types)
 657 {
 658   XdgMimeMagicMatch *match;
 659   const char *mime_type;
 660   int n;
 661
 662   mime_type = NULL;
 663   for (match = mime_magic->match_list; match; match = match->next)
 664     {
 665       if (_xdg_mime_magic_match_compare_to_data (match, data, len))
 666         {
 667           if ((mime_type == NULL) || (_xdg_mime_mime_type_subclass (match->mime_type, mime_type))) {
 668             mime_type = match->mime_type;
 669           }
 670         }
 671       else
 672         {
 673           for (n = 0; n < n_mime_types; n++)
 674             {
 675               if (mime_types[n] &&
 676                   _xdg_mime_mime_type_equal (mime_types[n], match->mime_type))
 677                 mime_types[n] = NULL;
 678             }
 679         }
 680     }
 681
 682   if (mime_type == NULL)
 683     {
 684       for (n = 0; n < n_mime_types; n++)
 685         {
 686           if (mime_types[n])
 687             mime_type = mime_types[n];
 688         }
 689     }
 690
 691   return mime_type;
 692 }
 693
 694 static void
 695 _xdg_mime_update_mime_magic_extents (XdgMimeMagic *mime_magic)
 696 {
 697   XdgMimeMagicMatch *match;
 698   int max_extent = 0;
 699
 700   for (match = mime_magic->match_list; match; match = match->next)
 701     {
 702       XdgMimeMagicMatchlet *matchlet;
 703
 704       for (matchlet = match->matchlet; matchlet; matchlet = matchlet->next)
 705         {
 706           int extent;
 707
 708           extent = matchlet->value_length + matchlet->offset + matchlet->range_length;
 709           if (max_extent < extent)
 710             max_extent = extent;
 711         }
 712     }
 713
 714   mime_magic->max_extent = max_extent;
 715 }
 716
 717 static XdgMimeMagicMatchlet *
 718 _xdg_mime_magic_matchlet_mirror (XdgMimeMagicMatchlet *matchlets)
 719 {
 720   XdgMimeMagicMatchlet *new_list;
 721   XdgMimeMagicMatchlet *tmp;
 722
 723   if ((matchlets == NULL) || (matchlets->next == NULL))
 724     return matchlets;
 725
 726   new_list = NULL;
 727   tmp = matchlets;
 728   while (tmp != NULL)
 729     {
 730       XdgMimeMagicMatchlet *matchlet;
 731
 732       matchlet = tmp;
 733       tmp = tmp->next;
 734       matchlet->next = new_list;
 735       new_list = matchlet;
 736     }
 737
 738   return new_list;
 739
 740 }
 741
 742 static void
 743 _xdg_mime_magic_read_magic_file (XdgMimeMagic *mime_magic,
 744                                  FILE         *magic_file)
 745 {
 746   XdgMimeMagicState state;
 747   XdgMimeMagicMatch *match = NULL; /* Quiet compiler */
 748
 749   state = XDG_MIME_MAGIC_SECTION;
 750
 751   while (state != XDG_MIME_MAGIC_EOF)
 752     {
 753       switch (state)
 754         {
 755         case XDG_MIME_MAGIC_SECTION:
 756           match = _xdg_mime_magic_match_new ();
 757           state = _xdg_mime_magic_parse_header (magic_file, match);
 758           if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
 759             _xdg_mime_magic_match_free (match);
 760           break;
 761         case XDG_MIME_MAGIC_MAGIC:
 762           state = _xdg_mime_magic_parse_magic_line (magic_file, match);
 763           if (state == XDG_MIME_MAGIC_SECTION ||
 764               (state == XDG_MIME_MAGIC_EOF && match->mime_type))
 765             {
 766               match->matchlet = _xdg_mime_magic_matchlet_mirror (match->matchlet);
 767               _xdg_mime_magic_insert_match (mime_magic, match);
 768             }
 769           else 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_ERROR:
 773           state = _xdg_mime_magic_parse_error (magic_file);
 774           break;
 775         case XDG_MIME_MAGIC_EOF:
 776         default:
 777           /* Make the compiler happy */
 778           assert (0);
 779         }
 780     }
 781   _xdg_mime_update_mime_magic_extents (mime_magic);
 782 }
 783
 784 void
 785 _xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
 786                                 const char   *file_name)
 787 {
 788   FILE *magic_file;
 789   char header[12];
 790
 791   magic_file = fopen (file_name, "r");
 792
 793   if (magic_file == NULL)
 794     return;
 795
 796   if (fread (header, 1, 12, magic_file) == 12)
 797     {
 798       if (memcmp ("MIME-Magic\0\n", header, 12) == 0)
 799         _xdg_mime_magic_read_magic_file (mime_magic, magic_file);
 800     }
 801
 802   fclose (magic_file);
 803 }