gio/xdgmime/xdgmimecache.c

   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 <errno.h>
  38 #include <fnmatch.h>
  39 #include <assert.h>
  40
  41 #include <netinet/in.h> /* for ntohl/ntohs */
  42
  43 #ifdef HAVE_MMAP
  44 #include <sys/mman.h>
  45 #else
  46 #warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used.
  47 #endif
  48
  49 #include <sys/stat.h>
  50 #include <sys/types.h>
  51
  52 #include "xdgmimecache.h"
  53 #include "xdgmimeint.h"
  54
  55 #ifndef MAX
  56 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  57 #endif
  58
  59 #ifndef FALSE
  60 #define FALSE   (0)
  61 #endif
  62
  63 #ifndef TRUE
  64 #define TRUE    (!FALSE)
  65 #endif
  66
  67 #ifndef _O_BINARY
  68 #define _O_BINARY 0
  69 #endif
  70
  71 #ifndef MAP_FAILED
  72 #define MAP_FAILED ((void *) -1)
  73 #endif
  74
  75 #define MAJOR_VERSION 1
  76 #define MINOR_VERSION_MIN 1
  77 #define MINOR_VERSION_MAX 2
  78
  79 struct _XdgMimeCache
  80 {
  81   int ref_count;
  82   int minor;
  83
  84   size_t  size;
  85   char   *buffer;
  86 };
  87
  88 #define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
  89 #define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
  90
  91 XdgMimeCache *
  92 _xdg_mime_cache_ref (XdgMimeCache *cache)
  93 {
  94   cache->ref_count++;
  95   return cache;
  96 }
  97
  98 void
  99 _xdg_mime_cache_unref (XdgMimeCache *cache)
 100 {
 101   cache->ref_count--;
 102
 103   if (cache->ref_count == 0)
 104     {
 105 #ifdef HAVE_MMAP
 106       munmap (cache->buffer, cache->size);
 107 #endif
 108       free (cache);
 109     }
 110 }
 111
 112 XdgMimeCache *
 113 _xdg_mime_cache_new_from_file (const char *file_name)
 114 {
 115   XdgMimeCache *cache = NULL;
 116
 117 #ifdef HAVE_MMAP
 118   int fd = -1;
 119   struct stat st;
 120   char *buffer = NULL;
 121   int minor;
 122
 123   /* Open the file and map it into memory */
 124   do
 125     fd = open (file_name, O_RDONLY|_O_BINARY, 0);
 126   while (fd == -1 && errno == EINTR);
 127
 128   if (fd < 0)
 129     return NULL;
 130
 131   if (fstat (fd, &st) < 0 || st.st_size < 4)
 132     goto done;
 133
 134   buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 135
 136   if (buffer == MAP_FAILED)
 137     goto done;
 138
 139   minor = GET_UINT16 (buffer, 2);
 140   /* Verify version */
 141   if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
 142       (minor < MINOR_VERSION_MIN ||
 143        minor > MINOR_VERSION_MAX))
 144     {
 145       munmap (buffer, st.st_size);
 146
 147       goto done;
 148     }
 149
 150   cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
 151   cache->minor = minor;
 152   cache->ref_count = 1;
 153   cache->buffer = buffer;
 154   cache->size = st.st_size;
 155
 156  done:
 157   if (fd != -1)
 158     close (fd);
 159
 160 #endif  /* HAVE_MMAP */
 161
 162   return cache;
 163 }
 164
 165 static int
 166 cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
 167                                       xdg_uint32_t  offset,
 168                                       const void   *data,
 169                                       size_t        len)
 170 {
 171   xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
 172   xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
 173   xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
 174   xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
 175   xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
 176
 177   int i, j;
 178
 179   for (i = range_start; i < range_start + range_length; i++)
 180     {
 181       int valid_matchlet = TRUE;
 182
 183       if (i + data_length > len)
 184         return FALSE;
 185
 186       if (mask_offset)
 187         {
 188           for (j = 0; j < data_length; j++)
 189             {
 190               if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
 191                   ((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
 192                 {
 193                   valid_matchlet = FALSE;
 194                   break;
 195                 }
 196             }
 197         }
 198       else
 199         {
 200           for (j = 0; j < data_length; j++)
 201             {
 202               if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
 203                 {
 204                   valid_matchlet = FALSE;
 205                   break;
 206                 }
 207             }
 208         }
 209
 210       if (valid_matchlet)
 211         return TRUE;
 212     }
 213
 214   return FALSE;
 215 }
 216
 217 static int
 218 cache_magic_matchlet_compare (XdgMimeCache *cache,
 219                               xdg_uint32_t  offset,
 220                               const void   *data,
 221                               size_t        len)
 222 {
 223   xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
 224   xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
 225
 226   int i;
 227
 228   if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
 229     {
 230       if (n_children == 0)
 231         return TRUE;
 232
 233       for (i = 0; i < n_children; i++)
 234         {
 235           if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
 236                                             data, len))
 237             return TRUE;
 238         }
 239     }
 240
 241   return FALSE;
 242 }
 243
 244 static const char *
 245 cache_magic_compare_to_data (XdgMimeCache *cache,
 246                              xdg_uint32_t  offset,
 247                              const void   *data,
 248                              size_t        len,
 249                              int          *prio)
 250 {
 251   xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
 252   xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
 253   xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
 254   xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
 255
 256   int i;
 257
 258   for (i = 0; i < n_matchlets; i++)
 259     {
 260       if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
 261                                         data, len))
 262         {
 263           *prio = priority;
 264
 265           return cache->buffer + mimetype_offset;
 266         }
 267     }
 268
 269   return NULL;
 270 }
 271
 272 static const char *
 273 cache_magic_lookup_data (XdgMimeCache *cache,
 274                          const void   *data,
 275                          size_t        len,
 276                          int          *prio,
 277                          const char   *mime_types[],
 278                          int           n_mime_types)
 279 {
 280   xdg_uint32_t list_offset;
 281   xdg_uint32_t n_entries;
 282   xdg_uint32_t offset;
 283
 284   int j, n;
 285
 286   *prio = 0;
 287
 288   list_offset = GET_UINT32 (cache->buffer, 24);
 289   n_entries = GET_UINT32 (cache->buffer, list_offset);
 290   offset = GET_UINT32 (cache->buffer, list_offset + 8);
 291
 292   for (j = 0; j < n_entries; j++)
 293     {
 294       const char *match;
 295
 296       match = cache_magic_compare_to_data (cache, offset + 16 * j,
 297                                            data, len, prio);
 298       if (match)
 299         return match;
 300       else
 301         {
 302           xdg_uint32_t mimetype_offset;
 303           const char *non_match;
 304
 305           mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
 306           non_match = cache->buffer + mimetype_offset;
 307
 308           for (n = 0; n < n_mime_types; n++)
 309             {
 310               if (mime_types[n] &&
 311                   _xdg_mime_mime_type_equal (mime_types[n], non_match))
 312                 mime_types[n] = NULL;
 313             }
 314         }
 315     }
 316
 317   return NULL;
 318 }
 319
 320 static const char *
 321 cache_alias_lookup (const char *alias)
 322 {
 323   const char *ptr;
 324   int i, min, max, mid, cmp;
 325
 326   for (i = 0; _caches[i]; i++)
 327     {
 328       XdgMimeCache *cache = _caches[i];
 329       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
 330       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 331       xdg_uint32_t offset;
 332
 333       min = 0;
 334       max = n_entries - 1;
 335       while (max >= min)
 336         {
 337           mid = (min + max) / 2;
 338
 339           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
 340           ptr = cache->buffer + offset;
 341           cmp = strcmp (ptr, alias);
 342
 343           if (cmp < 0)
 344             min = mid + 1;
 345           else if (cmp > 0)
 346             max = mid - 1;
 347           else
 348             {
 349               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
 350               return cache->buffer + offset;
 351             }
 352         }
 353     }
 354
 355   return NULL;
 356 }
 357
 358 typedef struct {
 359   const char *mime;
 360   int weight;
 361 } MimeWeight;
 362
 363 static int
 364 cache_glob_lookup_literal (const char *file_name,
 365                            const char *mime_types[],
 366                            int         n_mime_types,
 367                            int         case_sensitive_check)
 368 {
 369   const char *ptr;
 370   int i, min, max, mid, cmp;
 371
 372   for (i = 0; _caches[i]; i++)
 373     {
 374       XdgMimeCache *cache = _caches[i];
 375       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
 376       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 377       xdg_uint32_t offset;
 378
 379       min = 0;
 380       max = n_entries - 1;
 381       while (max >= min)
 382         {
 383           mid = (min + max) / 2;
 384
 385           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid);
 386           ptr = cache->buffer + offset;
 387           cmp = strcmp (ptr, file_name);
 388
 389           if (cmp < 0)
 390             min = mid + 1;
 391           else if (cmp > 0)
 392             max = mid - 1;
 393           else
 394             {
 395               int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 8);
 396               int case_sensitive = weight & 0x100;
 397               weight = weight & 0xff;
 398
 399               if (case_sensitive_check || !case_sensitive)
 400                 {
 401                   offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 4);
 402                   mime_types[0] = (const char *)(cache->buffer + offset);
 403
 404                   return 1;
 405                 }
 406               return 0;
 407             }
 408         }
 409     }
 410
 411   return 0;
 412 }
 413
 414 static int
 415 cache_glob_lookup_fnmatch (const char *file_name,
 416                            MimeWeight  mime_types[],
 417                            int         n_mime_types)
 418 {
 419   const char *mime_type;
 420   const char *ptr;
 421
 422   int i, j, n;
 423
 424   n = 0;
 425   for (i = 0; _caches[i]; i++)
 426     {
 427       XdgMimeCache *cache = _caches[i];
 428
 429       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
 430       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 431
 432       for (j = 0; j < n_entries && n < n_mime_types; j++)
 433         {
 434           xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j);
 435           xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 4);
 436           int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 8);
 437           weight = weight & 0xff;
 438           ptr = cache->buffer + offset;
 439           mime_type = cache->buffer + mimetype_offset;
 440
 441           /* FIXME: Not UTF-8 safe */
 442           if (fnmatch (ptr, file_name, 0) == 0)
 443             {
 444               mime_types[n].mime = mime_type;
 445               mime_types[n].weight = weight;
 446               n++;
 447             }
 448         }
 449
 450       if (n == n_mime_types)
 451         break;
 452     }
 453
 454   return n;
 455 }
 456
 457 static int
 458 cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
 459                                xdg_uint32_t   n_entries,
 460                                xdg_uint32_t   offset,
 461                                const char    *file_name,
 462                                int            len,
 463                                int            case_sensitive_check,
 464                                MimeWeight     mime_types[],
 465                                int            n_mime_types)
 466 {
 467   xdg_unichar_t character;
 468   xdg_unichar_t match_char;
 469   xdg_uint32_t mimetype_offset;
 470   xdg_uint32_t n_children;
 471   xdg_uint32_t child_offset;
 472   int weight;
 473   int case_sensitive;
 474
 475   int min, max, mid, n, i;
 476
 477   character = file_name[len - 1];
 478
 479   assert (character != 0);
 480
 481   min = 0;
 482   max = n_entries - 1;
 483   while (max >= min)
 484     {
 485       mid = (min + max) /  2;
 486       match_char = GET_UINT32 (cache->buffer, offset + 12 * mid);
 487       if (match_char < character)
 488         min = mid + 1;
 489       else if (match_char > character)
 490         max = mid - 1;
 491       else
 492         {
 493           len--;
 494           n = 0;
 495           n_children = GET_UINT32 (cache->buffer, offset + 12 * mid + 4);
 496           child_offset = GET_UINT32 (cache->buffer, offset + 12 * mid + 8);
 497
 498           if (len > 0)
 499             {
 500               n = cache_glob_node_lookup_suffix (cache,
 501                                                  n_children, child_offset,
 502                                                  file_name, len,
 503                                                  case_sensitive_check,
 504                                                  mime_types,
 505                                                  n_mime_types);
 506             }
 507           if (n == 0)
 508             {
 509               i = 0;
 510               while (n < n_mime_types && i < n_children)
 511                 {
 512                   match_char = GET_UINT32 (cache->buffer, child_offset + 12 * i);
 513                   if (match_char != 0)
 514                     break;
 515
 516                   mimetype_offset = GET_UINT32 (cache->buffer, child_offset + 12 * i + 4);
 517                   weight = GET_UINT32 (cache->buffer, child_offset + 12 * i + 8);
 518                   case_sensitive = weight & 0x100;
 519                   weight = weight & 0xff;
 520
 521                   if (case_sensitive_check || !case_sensitive)
 522                     {
 523                       mime_types[n].mime = cache->buffer + mimetype_offset;
 524                       mime_types[n].weight = weight;
 525                       n++;
 526                     }
 527                   i++;
 528                 }
 529             }
 530           return n;
 531         }
 532     }
 533   return 0;
 534 }
 535
 536 static int
 537 cache_glob_lookup_suffix (const char *file_name,
 538                           int         len,
 539                           int         ignore_case,
 540                           MimeWeight  mime_types[],
 541                           int         n_mime_types)
 542 {
 543   int i, n;
 544
 545   n = 0;
 546   for (i = 0; _caches[i]; i++)
 547     {
 548       XdgMimeCache *cache = _caches[i];
 549
 550       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
 551       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 552       xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
 553
 554       n += cache_glob_node_lookup_suffix (cache,
 555                                           n_entries, offset,
 556                                           file_name, len,
 557                                           ignore_case,
 558                                           mime_types + n,
 559                                           n_mime_types - n);
 560       if (n == n_mime_types)
 561         break;
 562     }
 563
 564   return n;
 565 }
 566
 567 static int compare_mime_weight (const void *a, const void *b)
 568 {
 569   const MimeWeight *aa = (const MimeWeight *)a;
 570   const MimeWeight *bb = (const MimeWeight *)b;
 571
 572   return bb->weight - aa->weight;
 573 }
 574
 575 #define ISUPPER(c)              ((c) >= 'A' && (c) <= 'Z')
 576 static char *
 577 ascii_tolower (const char *str)
 578 {
 579   char *p, *lower;
 580
 581   lower = strdup (str);
 582   p = lower;
 583   while (*p != 0)
 584     {
 585       char c = *p;
 586       *p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
 587     }
 588   return lower;
 589 }
 590
 591 static int
 592 filter_out_dupes (MimeWeight mimes[], int n_mimes)
 593 {
 594   int last;
 595   int i, j;
 596
 597   last = n_mimes;
 598
 599   for (i = 0; i < last; i++)
 600     {
 601       j = i + 1;
 602       while (j < last)
 603         {
 604           if (strcmp (mimes[i].mime, mimes[j].mime) == 0)
 605             {
 606               mimes[i].weight = MAX (mimes[i].weight, mimes[j].weight);
 607               last--;
 608               mimes[j].mime = mimes[last].mime;
 609               mimes[j].weight = mimes[last].weight;
 610             }
 611           else
 612             j++;
 613         }
 614     }
 615
 616   return last;
 617 }
 618
 619 static int
 620 cache_glob_lookup_file_name (const char *file_name,
 621                              const char *mime_types[],
 622                              int         n_mime_types)
 623 {
 624   int n;
 625   MimeWeight mimes[10];
 626   int n_mimes = 10;
 627   int i;
 628   int len;
 629   char *lower_case;
 630
 631   assert (file_name != NULL && n_mime_types > 0);
 632
 633   /* First, check the literals */
 634
 635   lower_case = ascii_tolower (file_name);
 636
 637   n = cache_glob_lookup_literal (lower_case, mime_types, n_mime_types, FALSE);
 638   if (n > 0)
 639     {
 640       free (lower_case);
 641       return n;
 642     }
 643
 644   n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types, TRUE);
 645   if (n > 0)
 646     {
 647       free (lower_case);
 648       return n;
 649     }
 650
 651   len = strlen (file_name);
 652   n = cache_glob_lookup_suffix (lower_case, len, FALSE, mimes, n_mimes);
 653   if (n < 2)
 654     n += cache_glob_lookup_suffix (file_name, len, TRUE, mimes + n, n_mimes - n);
 655
 656   free (lower_case);
 657
 658   /* Last, try fnmatch */
 659   if (n < 2)
 660     n += cache_glob_lookup_fnmatch (file_name, mimes + n, n_mimes - n);
 661
 662   n = filter_out_dupes (mimes, n);
 663
 664   qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
 665
 666   if (n_mime_types < n)
 667     n = n_mime_types;
 668
 669   for (i = 0; i < n; i++)
 670     mime_types[i] = mimes[i].mime;
 671
 672   return n;
 673 }
 674
 675 int
 676 _xdg_mime_cache_get_max_buffer_extents (void)
 677 {
 678   xdg_uint32_t offset;
 679   xdg_uint32_t max_extent;
 680   int i;
 681
 682   max_extent = 0;
 683   for (i = 0; _caches[i]; i++)
 684     {
 685       XdgMimeCache *cache = _caches[i];
 686
 687       offset = GET_UINT32 (cache->buffer, 24);
 688       max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
 689     }
 690
 691   return max_extent;
 692 }
 693
 694 static const char *
 695 cache_get_mime_type_for_data (const void *data,
 696                               size_t      len,
 697                               int        *result_prio,
 698                               const char *mime_types[],
 699                               int         n_mime_types)
 700 {
 701   const char *mime_type;
 702   int i, n, priority;
 703
 704   priority = 0;
 705   mime_type = NULL;
 706   for (i = 0; _caches[i]; i++)
 707     {
 708       XdgMimeCache *cache = _caches[i];
 709
 710       int prio;
 711       const char *match;
 712
 713       match = cache_magic_lookup_data (cache, data, len, &prio,
 714                                        mime_types, n_mime_types);
 715       if (prio > priority)
 716         {
 717           priority = prio;
 718           mime_type = match;
 719         }
 720     }
 721
 722   if (result_prio)
 723     *result_prio = priority;
 724
 725   if (priority > 0)
 726     return mime_type;
 727
 728   for (n = 0; n < n_mime_types; n++)
 729     {
 730
 731       if (mime_types[n])
 732         return mime_types[n];
 733     }
 734
 735   return XDG_MIME_TYPE_UNKNOWN;
 736 }
 737
 738 const char *
 739 _xdg_mime_cache_get_mime_type_for_data (const void *data,
 740                                         size_t      len,
 741                                         int        *result_prio)
 742 {
 743   return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0);
 744 }
 745
 746 #ifdef NOT_USED_IN_GIO
 747
 748 const char *
 749 _xdg_mime_cache_get_mime_type_for_file (const char  *file_name,
 750                                         struct stat *statbuf)
 751 {
 752   const char *mime_type;
 753   const char *mime_types[10];
 754   FILE *file;
 755   unsigned char *data;
 756   int max_extent;
 757   int bytes_read;
 758   struct stat buf;
 759   const char *base_name;
 760   int n;
 761
 762   if (file_name == NULL)
 763     return NULL;
 764
 765   if (! _xdg_utf8_validate (file_name))
 766     return NULL;
 767
 768   base_name = _xdg_get_base_name (file_name);
 769   n = cache_glob_lookup_file_name (base_name, mime_types, 10);
 770
 771   if (n == 1)
 772     return mime_types[0];
 773
 774   if (!statbuf)
 775     {
 776       if (stat (file_name, &buf) != 0)
 777         return XDG_MIME_TYPE_UNKNOWN;
 778
 779       statbuf = &buf;
 780     }
 781
 782   if (!S_ISREG (statbuf->st_mode))
 783     return XDG_MIME_TYPE_UNKNOWN;
 784
 785   /* FIXME: Need to make sure that max_extent isn't totally broken.  This could
 786    * be large and need getting from a stream instead of just reading it all
 787    * in. */
 788   max_extent = _xdg_mime_cache_get_max_buffer_extents ();
 789   data = malloc (max_extent);
 790   if (data == NULL)
 791     return XDG_MIME_TYPE_UNKNOWN;
 792
 793   file = fopen (file_name, "r");
 794   if (file == NULL)
 795     {
 796       free (data);
 797       return XDG_MIME_TYPE_UNKNOWN;
 798     }
 799
 800   bytes_read = fread (data, 1, max_extent, file);
 801   if (ferror (file))
 802     {
 803       free (data);
 804       fclose (file);
 805       return XDG_MIME_TYPE_UNKNOWN;
 806     }
 807
 808   mime_type = cache_get_mime_type_for_data (data, bytes_read, NULL,
 809                                             mime_types, n);
 810
 811   free (data);
 812   fclose (file);
 813
 814   return mime_type;
 815 }
 816
 817 const char *
 818 _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
 819 {
 820   const char *mime_type;
 821
 822   if (cache_glob_lookup_file_name (file_name, &mime_type, 1))
 823     return mime_type;
 824   else
 825     return XDG_MIME_TYPE_UNKNOWN;
 826 }
 827
 828 #endif
 829
 830 int
 831 _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
 832                                                const char  *mime_types[],
 833                                                int          n_mime_types)
 834 {
 835   return cache_glob_lookup_file_name (file_name, mime_types, n_mime_types);
 836 }
 837
 838 #if 1
 839 static int
 840 ends_with (const char *str,
 841            const char *suffix)
 842 {
 843   int length;
 844   int suffix_length;
 845
 846   length = strlen (str);
 847   suffix_length = strlen (suffix);
 848   if (length < suffix_length)
 849     return 0;
 850
 851   if (strcmp (str + length - suffix_length, suffix) == 0)
 852     return 1;
 853
 854   return 0;
 855 }
 856
 857 static int
 858 is_super_type (const char *mime)
 859 {
 860   return ends_with (mime, "/*");
 861 }
 862 #endif
 863
 864 int
 865 _xdg_mime_cache_mime_type_subclass (const char *mime,
 866                                     const char *base)
 867 {
 868   const char *umime, *ubase;
 869
 870   int i, j, min, max, med, cmp;
 871
 872   umime = _xdg_mime_cache_unalias_mime_type (mime);
 873   ubase = _xdg_mime_cache_unalias_mime_type (base);
 874
 875   if (strcmp (umime, ubase) == 0)
 876     return 1;
 877
 878   /* We really want to handle text/ * in GtkFileFilter, so we just
 879    * turn on the supertype matching
 880    */
 881 #if 1
 882   /* Handle supertypes */
 883   if (is_super_type (ubase) &&
 884       xdg_mime_media_type_equal (umime, ubase))
 885     return 1;
 886 #endif
 887
 888   /*  Handle special cases text/plain and application/octet-stream */
 889   if (strcmp (ubase, "text/plain") == 0 &&
 890       strncmp (umime, "text/", 5) == 0)
 891     return 1;
 892
 893   if (strcmp (ubase, "application/octet-stream") == 0)
 894     return 1;
 895
 896   for (i = 0; _caches[i]; i++)
 897     {
 898       XdgMimeCache *cache = _caches[i];
 899
 900       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
 901       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 902       xdg_uint32_t offset, n_parents, parent_offset;
 903
 904       min = 0;
 905       max = n_entries - 1;
 906       while (max >= min)
 907         {
 908           med = (min + max)/2;
 909
 910           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
 911           cmp = strcmp (cache->buffer + offset, umime);
 912           if (cmp < 0)
 913             min = med + 1;
 914           else if (cmp > 0)
 915             max = med - 1;
 916           else
 917             {
 918               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
 919               n_parents = GET_UINT32 (cache->buffer, offset);
 920
 921               for (j = 0; j < n_parents; j++)
 922                 {
 923                   parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
 924                   if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
 925                     return 1;
 926                 }
 927
 928               break;
 929             }
 930         }
 931     }
 932
 933   return 0;
 934 }
 935
 936 const char *
 937 _xdg_mime_cache_unalias_mime_type (const char *mime)
 938 {
 939   const char *lookup;
 940
 941   lookup = cache_alias_lookup (mime);
 942
 943   if (lookup)
 944     return lookup;
 945
 946   return mime;
 947 }
 948
 949 char **
 950 _xdg_mime_cache_list_mime_parents (const char *mime)
 951 {
 952   int i, j, k, l, p;
 953   char *all_parents[128]; /* we'll stop at 128 */
 954   char **result;
 955
 956   mime = xdg_mime_unalias_mime_type (mime);
 957
 958   p = 0;
 959   for (i = 0; _caches[i]; i++)
 960     {
 961       XdgMimeCache *cache = _caches[i];
 962
 963       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
 964       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 965
 966       for (j = 0; j < n_entries; j++)
 967         {
 968           xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
 969           xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
 970
 971           if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
 972             {
 973               xdg_uint32_t parent_mime_offset;
 974               xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
 975
 976               for (k = 0; k < n_parents && p < 127; k++)
 977                 {
 978                   parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
 979
 980                   /* Don't add same parent multiple times.
 981                    * This can happen for instance if the same type is listed in multiple directories
 982                    */
 983                   for (l = 0; l < p; l++)
 984                     {
 985                       if (strcmp (all_parents[l], cache->buffer + parent_mime_offset) == 0)
 986                         break;
 987                     }
 988
 989                   if (l == p)
 990                     all_parents[p++] = cache->buffer + parent_mime_offset;
 991                 }
 992
 993               break;
 994             }
 995         }
 996     }
 997   all_parents[p++] = NULL;
 998
 999   result = (char **) malloc (p * sizeof (char *));
1000   memcpy (result, all_parents, p * sizeof (char *));
1001
1002   return result;
1003 }
1004
1005 static const char *
1006 cache_lookup_icon (const char *mime, int header)
1007 {
1008   const char *ptr;
1009   int i, min, max, mid, cmp;
1010
1011   for (i = 0; _caches[i]; i++)
1012     {
1013       XdgMimeCache *cache = _caches[i];
1014       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, header);
1015       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
1016       xdg_uint32_t offset;
1017
1018       min = 0;
1019       max = n_entries - 1;
1020       while (max >= min)
1021         {
1022           mid = (min + max) / 2;
1023
1024           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
1025           ptr = cache->buffer + offset;
1026           cmp = strcmp (ptr, mime);
1027
1028           if (cmp < 0)
1029             min = mid + 1;
1030           else if (cmp > 0)
1031             max = mid - 1;
1032           else
1033             {
1034               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
1035               return cache->buffer + offset;
1036             }
1037         }
1038     }
1039
1040   return NULL;
1041 }
1042
1043 const char *
1044 _xdg_mime_cache_get_generic_icon (const char *mime)
1045 {
1046   return cache_lookup_icon (mime, 36);
1047 }
1048
1049 const char *
1050 _xdg_mime_cache_get_icon (const char *mime)
1051 {
1052   return cache_lookup_icon (mime, 32);
1053 }
1054
1055 #ifdef NOT_USED_IN_GIO
1056
1057 static void
1058 dump_glob_node (XdgMimeCache *cache,
1059                 xdg_uint32_t  offset,
1060                 int           depth)
1061 {
1062   xdg_unichar_t character;
1063   xdg_uint32_t mime_offset;
1064   xdg_uint32_t n_children;
1065   xdg_uint32_t child_offset;
1066   int i;
1067
1068   character = GET_UINT32 (cache->buffer, offset);
1069   mime_offset = GET_UINT32 (cache->buffer, offset + 4);
1070   n_children = GET_UINT32 (cache->buffer, offset + 8);
1071   child_offset = GET_UINT32 (cache->buffer, offset + 12);
1072   for (i = 0; i < depth; i++)
1073     printf (" ");
1074   printf ("%c", character);
1075   if (mime_offset)
1076     printf (" - %s", cache->buffer + mime_offset);
1077   printf ("\n");
1078   if (child_offset)
1079   {
1080     for (i = 0; i < n_children; i++)
1081       dump_glob_node (cache, child_offset + 20 * i, depth + 1);
1082   }
1083 }
1084
1085 void
1086 _xdg_mime_cache_glob_dump (void)
1087 {
1088   int i, j;
1089   for (i = 0; _caches[i]; i++)
1090   {
1091     XdgMimeCache *cache = _caches[i];
1092     xdg_uint32_t list_offset;
1093     xdg_uint32_t n_entries;
1094     xdg_uint32_t offset;
1095     list_offset = GET_UINT32 (cache->buffer, 16);
1096     n_entries = GET_UINT32 (cache->buffer, list_offset);
1097     offset = GET_UINT32 (cache->buffer, list_offset + 4);
1098     for (j = 0; j < n_entries; j++)
1099             dump_glob_node (cache, offset + 20 * j, 0);
1100   }
1101 }
1102
1103 #endif