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