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 #endif
  45
  46 #include <sys/stat.h>
  47 #include <sys/types.h>
  48
  49 #include "xdgmimecache.h"
  50 #include "xdgmimeint.h"
  51
  52 #ifndef MAX
  53 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  54 #endif
  55
  56 #ifndef FALSE
  57 #define FALSE   (0)
  58 #endif
  59
  60 #ifndef TRUE
  61 #define TRUE    (!FALSE)
  62 #endif
  63
  64 #ifndef _O_BINARY
  65 #define _O_BINARY 0
  66 #endif
  67
  68 #define MAJOR_VERSION 1
  69 #define MINOR_VERSION 0
  70
  71 extern XdgMimeCache **caches;
  72 extern int n_caches;
  73
  74 struct _XdgMimeCache
  75 {
  76   int ref_count;
  77
  78   size_t  size;
  79   char   *buffer;
  80 };
  81
  82 #define GET_UINT16(cache,offset) (ntohs(*(uint16_t*)((cache) + (offset))))
  83 #define GET_UINT32(cache,offset) (ntohl(*(uint32_t*)((cache) + (offset))))
  84
  85 XdgMimeCache *
  86 _xdg_mime_cache_ref (XdgMimeCache *cache)
  87 {
  88   cache->ref_count++;
  89   return cache;
  90 }
  91
  92 void
  93 _xdg_mime_cache_unref (XdgMimeCache *cache)
  94 {
  95   cache->ref_count--;
  96
  97   if (cache->ref_count == 0)
  98     {
  99 #ifdef HAVE_MMAP
 100       munmap (cache->buffer, cache->size);
 101 #endif
 102       free (cache);
 103     }
 104 }
 105
 106 XdgMimeCache *
 107 _xdg_mime_cache_new_from_file (const char *file_name)
 108 {
 109   XdgMimeCache *cache = NULL;
 110
 111 #ifdef HAVE_MMAP
 112   int fd = -1;
 113   struct stat st;
 114   char *buffer = NULL;
 115
 116   /* Open the file and map it into memory */
 117   fd = open (file_name, O_RDONLY|_O_BINARY, 0);
 118
 119   if (fd < 0)
 120     return NULL;
 121
 122   if (fstat (fd, &st) < 0 || st.st_size < 4)
 123     goto done;
 124
 125   buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 126
 127   if (buffer == MAP_FAILED)
 128     goto done;
 129
 130   /* Verify version */
 131   if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
 132       GET_UINT16 (buffer, 2) != MINOR_VERSION)
 133     {
 134       munmap (buffer, st.st_size);
 135
 136       goto done;
 137     }
 138
 139   cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
 140   cache->ref_count = 1;
 141   cache->buffer = buffer;
 142   cache->size = st.st_size;
 143
 144  done:
 145   if (fd != -1)
 146     close (fd);
 147
 148 #endif  /* HAVE_MMAP */
 149
 150   return cache;
 151 }
 152
 153 static int
 154 cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
 155                                       xdg_uint32_t  offset,
 156                                       const void   *data,
 157                                       size_t        len)
 158 {
 159   xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
 160   xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
 161   xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
 162   xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
 163   xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
 164
 165   int i, j;
 166
 167   for (i = range_start; i <= range_start + range_length; i++)
 168     {
 169       int valid_matchlet = TRUE;
 170
 171       if (i + data_length > len)
 172         return FALSE;
 173
 174       if (mask_offset)
 175         {
 176           for (j = 0; j < data_length; j++)
 177             {
 178               if ((cache->buffer[data_offset + j] & cache->buffer[mask_offset + j]) !=
 179                   ((((unsigned char *) data)[j + i]) & cache->buffer[mask_offset + j]))
 180                 {
 181                   valid_matchlet = FALSE;
 182                   break;
 183                 }
 184             }
 185         }
 186       else
 187         {
 188           for (j = 0; j < data_length; j++)
 189             {
 190               if (cache->buffer[data_offset + j] != ((unsigned char *) data)[j + i])
 191                 {
 192                   valid_matchlet = FALSE;
 193                   break;
 194                 }
 195             }
 196         }
 197
 198       if (valid_matchlet)
 199         return TRUE;
 200     }
 201
 202   return FALSE;
 203 }
 204
 205 static int
 206 cache_magic_matchlet_compare (XdgMimeCache *cache,
 207                               xdg_uint32_t  offset,
 208                               const void   *data,
 209                               size_t        len)
 210 {
 211   xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
 212   xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
 213
 214   int i;
 215
 216   if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
 217     {
 218       if (n_children == 0)
 219         return TRUE;
 220
 221       for (i = 0; i < n_children; i++)
 222         {
 223           if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
 224                                             data, len))
 225             return TRUE;
 226         }
 227     }
 228
 229   return FALSE;
 230 }
 231
 232 static const char *
 233 cache_magic_compare_to_data (XdgMimeCache *cache,
 234                              xdg_uint32_t  offset,
 235                              const void   *data,
 236                              size_t        len,
 237                              int          *prio)
 238 {
 239   xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
 240   xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
 241   xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
 242   xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
 243
 244   int i;
 245
 246   for (i = 0; i < n_matchlets; i++)
 247     {
 248       if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32,
 249                                         data, len))
 250         {
 251           *prio = priority;
 252
 253           return cache->buffer + mimetype_offset;
 254         }
 255     }
 256
 257   return NULL;
 258 }
 259
 260 static const char *
 261 cache_magic_lookup_data (XdgMimeCache *cache,
 262                          const void   *data,
 263                          size_t        len,
 264                          int          *prio)
 265 {
 266   xdg_uint32_t list_offset;
 267   xdg_uint32_t n_entries;
 268   xdg_uint32_t offset;
 269
 270   int j;
 271
 272   *prio = 0;
 273
 274   list_offset = GET_UINT32 (cache->buffer, 24);
 275   n_entries = GET_UINT32 (cache->buffer, list_offset);
 276   offset = GET_UINT32 (cache->buffer, list_offset + 8);
 277
 278   for (j = 0; j < n_entries; j++)
 279     {
 280       const char *match = cache_magic_compare_to_data (cache, offset + 16 * j,
 281                                                        data, len, prio);
 282       if (match)
 283         return match;
 284     }
 285
 286   return NULL;
 287 }
 288
 289 static const char *
 290 cache_alias_lookup (const char *alias)
 291 {
 292   const char *ptr;
 293   int i, min, max, mid, cmp;
 294
 295   for (i = 0; i < n_caches; i++)
 296     {
 297       XdgMimeCache *cache = caches[i];
 298       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4 );
 299       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 300       xdg_uint32_t offset;
 301
 302       min = 0;
 303       max = n_entries - 1;
 304       while (max >= min)
 305         {
 306           mid = (min + max) / 2;
 307
 308           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
 309           ptr = cache->buffer + offset;
 310           cmp = strcmp (ptr, alias);
 311
 312           if (cmp < 0)
 313             min = mid + 1;
 314           else if (cmp > 0)
 315             max = mid - 1;
 316           else
 317             {
 318               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
 319               return cache->buffer + offset;
 320             }
 321         }
 322     }
 323
 324   return NULL;
 325 }
 326
 327 static const char *
 328 cache_glob_lookup_literal (const char *file_name)
 329 {
 330   const char *ptr;
 331   int i, min, max, mid, cmp;
 332
 333   for (i = 0; i < n_caches; i++)
 334     {
 335       XdgMimeCache *cache = caches[i];
 336       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
 337       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 338       xdg_uint32_t offset;
 339
 340       min = 0;
 341       max = n_entries - 1;
 342       while (max >= min)
 343         {
 344           mid = (min + max) / 2;
 345
 346           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
 347           ptr = cache->buffer + offset;
 348           cmp = strcmp (ptr, file_name);
 349
 350           if (cmp < 0)
 351             min = mid + 1;
 352           else if (cmp > 0)
 353             max = mid - 1;
 354           else
 355             {
 356               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
 357               return  cache->buffer + offset;
 358             }
 359         }
 360     }
 361
 362   return NULL;
 363 }
 364
 365 static const char *
 366 cache_glob_lookup_fnmatch (const char *file_name)
 367 {
 368   const char *mime_type;
 369   const char *ptr;
 370
 371   int i, j;
 372
 373   for (i = 0; i < n_caches; i++)
 374     {
 375       XdgMimeCache *cache = caches[i];
 376
 377       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
 378       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 379
 380       for (j = 0; j < n_entries; j++)
 381         {
 382           xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
 383           xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
 384           ptr = cache->buffer + offset;
 385           mime_type = cache->buffer + mimetype_offset;
 386
 387           /* FIXME: Not UTF-8 safe */
 388           if (fnmatch (ptr, file_name, 0) == 0)
 389             return mime_type;
 390         }
 391     }
 392
 393   return NULL;
 394 }
 395
 396 static const char *
 397 cache_glob_node_lookup_suffix (XdgMimeCache *cache,
 398                                xdg_uint32_t  n_entries,
 399                                xdg_uint32_t  offset,
 400                                const char   *suffix,
 401                                int           ignore_case)
 402 {
 403   xdg_unichar_t character;
 404   xdg_unichar_t match_char;
 405   xdg_uint32_t mimetype_offset;
 406   xdg_uint32_t n_children;
 407   xdg_uint32_t child_offset;
 408
 409   int min, max, mid;
 410
 411   character = _xdg_utf8_to_ucs4 (suffix);
 412   if (ignore_case)
 413     character = _xdg_ucs4_to_lower (character);
 414
 415   min = 0;
 416   max = n_entries - 1;
 417   while (max >= min)
 418     {
 419       mid = (min + max) /  2;
 420
 421       match_char = GET_UINT32 (cache->buffer, offset + 16 * mid);
 422
 423       if (match_char < character)
 424         min = mid + 1;
 425       else if (match_char > character)
 426         max = mid - 1;
 427       else
 428         {
 429           suffix = _xdg_utf8_next_char (suffix);
 430           if (*suffix == '\0')
 431             {
 432               mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 4);
 433
 434               return cache->buffer + mimetype_offset;
 435             }
 436           else
 437             {
 438               n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
 439               child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
 440
 441               return cache_glob_node_lookup_suffix (cache,
 442                                                     n_children, child_offset,
 443                                                     suffix, ignore_case);
 444             }
 445         }
 446     }
 447
 448   return NULL;
 449 }
 450
 451 static const char *
 452 cache_glob_lookup_suffix (const char *suffix,
 453                           int         ignore_case)
 454 {
 455   const char *mime_type;
 456
 457   int i;
 458
 459   for (i = 0; i < n_caches; i++)
 460     {
 461       XdgMimeCache *cache = caches[i];
 462
 463       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
 464       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 465       xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
 466
 467       mime_type = cache_glob_node_lookup_suffix (cache,
 468                                                  n_entries, offset,
 469                                                  suffix, ignore_case);
 470       if (mime_type)
 471         return mime_type;
 472     }
 473
 474   return NULL;
 475 }
 476
 477 static void
 478 find_stopchars (char *stopchars)
 479 {
 480   int i, j, k, l;
 481
 482   k = 0;
 483   for (i = 0; i < n_caches; i++)
 484     {
 485       XdgMimeCache *cache = caches[i];
 486
 487       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
 488       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 489       xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
 490
 491       for (j = 0; j < n_entries; j++)
 492         {
 493           xdg_uint32_t match_char = GET_UINT32 (cache->buffer, offset);
 494
 495           if (match_char < 128)
 496             {
 497               for (l = 0; l < k; l++)
 498                 if (stopchars[l] == match_char)
 499                   break;
 500               if (l == k)
 501                 {
 502                   stopchars[k] = (char) match_char;
 503                   k++;
 504                 }
 505             }
 506
 507           offset += 16;
 508         }
 509     }
 510
 511   stopchars[k] = '\0';
 512 }
 513
 514 static const char *
 515 cache_glob_lookup_file_name (const char *file_name)
 516 {
 517   const char *mime_type;
 518   const char *ptr;
 519   char stopchars[128];
 520
 521   assert (file_name != NULL);
 522
 523   /* First, check the literals */
 524   mime_type = cache_glob_lookup_literal (file_name);
 525   if (mime_type)
 526     return mime_type;
 527
 528   find_stopchars (stopchars);
 529
 530   /* Next, check suffixes */
 531   ptr = strpbrk (file_name, stopchars);
 532   while (ptr)
 533     {
 534       mime_type = cache_glob_lookup_suffix (ptr, FALSE);
 535       if (mime_type != NULL)
 536         return mime_type;
 537
 538       mime_type = cache_glob_lookup_suffix (ptr, TRUE);
 539       if (mime_type != NULL)
 540         return mime_type;
 541
 542       ptr = strpbrk (ptr + 1, stopchars);
 543     }
 544
 545   /* Last, try fnmatch */
 546   return cache_glob_lookup_fnmatch (file_name);
 547 }
 548
 549 int
 550 _xdg_mime_cache_get_max_buffer_extents (void)
 551 {
 552   xdg_uint32_t offset;
 553   xdg_uint32_t max_extent;
 554   int i;
 555
 556   max_extent = 0;
 557   for (i = 0; i < n_caches; i++)
 558     {
 559       XdgMimeCache *cache = caches[i];
 560
 561       offset = GET_UINT32 (cache->buffer, 24);
 562       max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
 563     }
 564
 565   return max_extent;
 566 }
 567
 568 const char *
 569 _xdg_mime_cache_get_mime_type_for_data (const void *data,
 570                                         size_t      len)
 571 {
 572   const char *mime_type;
 573   int i, priority;
 574
 575   priority = 0;
 576   mime_type = NULL;
 577   for (i = 0; i < n_caches; i++)
 578     {
 579       XdgMimeCache *cache = caches[i];
 580
 581       int prio;
 582       const char *match;
 583
 584       match = cache_magic_lookup_data (cache, data, len, &prio);
 585       if (prio > priority)
 586         {
 587           priority = prio;
 588           mime_type = match;
 589         }
 590     }
 591
 592   if (priority > 0)
 593     return mime_type;
 594
 595   return XDG_MIME_TYPE_UNKNOWN;
 596 }
 597
 598 const char *
 599 _xdg_mime_cache_get_mime_type_for_file (const char *file_name)
 600 {
 601   const char *mime_type;
 602   FILE *file;
 603   unsigned char *data;
 604   int max_extent;
 605   int bytes_read;
 606   struct stat statbuf;
 607   const char *base_name;
 608
 609   if (file_name == NULL)
 610     return NULL;
 611
 612   if (! _xdg_utf8_validate (file_name))
 613     return NULL;
 614
 615   base_name = _xdg_get_base_name (file_name);
 616   mime_type = _xdg_mime_cache_get_mime_type_from_file_name (base_name);
 617
 618   if (mime_type != XDG_MIME_TYPE_UNKNOWN)
 619     return mime_type;
 620
 621   if (stat (file_name, &statbuf) != 0)
 622     return XDG_MIME_TYPE_UNKNOWN;
 623
 624   if (!S_ISREG (statbuf.st_mode))
 625     return XDG_MIME_TYPE_UNKNOWN;
 626
 627   /* FIXME: Need to make sure that max_extent isn't totally broken.  This could
 628    * be large and need getting from a stream instead of just reading it all
 629    * in. */
 630   max_extent = _xdg_mime_cache_get_max_buffer_extents ();
 631   data = malloc (max_extent);
 632   if (data == NULL)
 633     return XDG_MIME_TYPE_UNKNOWN;
 634
 635   file = fopen (file_name, "r");
 636   if (file == NULL)
 637     {
 638       free (data);
 639       return XDG_MIME_TYPE_UNKNOWN;
 640     }
 641
 642   bytes_read = fread (data, 1, max_extent, file);
 643   if (ferror (file))
 644     {
 645       free (data);
 646       fclose (file);
 647       return XDG_MIME_TYPE_UNKNOWN;
 648     }
 649
 650   mime_type = _xdg_mime_cache_get_mime_type_for_data (data, bytes_read);
 651
 652   free (data);
 653   fclose (file);
 654
 655   return mime_type;
 656 }
 657
 658 const char *
 659 _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
 660 {
 661   const char *mime_type;
 662
 663   mime_type = cache_glob_lookup_file_name (file_name);
 664
 665   if (mime_type)
 666     return mime_type;
 667   else
 668     return XDG_MIME_TYPE_UNKNOWN;
 669 }
 670
 671 #if 1
 672 static int
 673 is_super_type (const char *mime)
 674 {
 675   int length;
 676   const char *type;
 677
 678   length = strlen (mime);
 679   type = &(mime[length - 2]);
 680
 681   if (strcmp (type, "/*") == 0)
 682     return 1;
 683
 684   return 0;
 685 }
 686 #endif
 687
 688 int
 689 _xdg_mime_cache_mime_type_subclass (const char *mime,
 690                                     const char *base)
 691 {
 692   const char *umime, *ubase;
 693
 694   int i, j, min, max, med, cmp;
 695
 696   umime = _xdg_mime_cache_unalias_mime_type (mime);
 697   ubase = _xdg_mime_cache_unalias_mime_type (base);
 698
 699   if (strcmp (umime, ubase) == 0)
 700     return 1;
 701
 702   /* We really want to handle text/ * in GtkFileFilter, so we just
 703    * turn on the supertype matching
 704    */
 705 #if 1
 706   /* Handle supertypes */
 707   if (is_super_type (ubase) &&
 708       xdg_mime_media_type_equal (umime, ubase))
 709     return 1;
 710 #endif
 711
 712   /*  Handle special cases text/plain and application/octet-stream */
 713   if (strcmp (ubase, "text/plain") == 0 &&
 714       strncmp (umime, "text/", 5) == 0)
 715     return 1;
 716
 717   if (strcmp (ubase, "application/octet-stream") == 0)
 718     return 1;
 719
 720   for (i = 0; i < n_caches; i++)
 721     {
 722       XdgMimeCache *cache = caches[i];
 723
 724       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
 725       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 726       xdg_uint32_t offset, n_parents, parent_offset;
 727
 728       min = 0;
 729       max = n_entries - 1;
 730       while (max >= min)
 731         {
 732           med = (min + max)/2;
 733
 734           offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
 735           cmp = strcmp (cache->buffer + offset, umime);
 736           if (cmp < 0)
 737             min = med + 1;
 738           else if (cmp > 0)
 739             max = med - 1;
 740           else
 741             {
 742               offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
 743               n_parents = GET_UINT32 (cache->buffer, offset);
 744
 745               for (j = 0; j < n_parents; j++)
 746                 {
 747                   parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
 748                   if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
 749                     return 1;
 750                 }
 751
 752               break;
 753             }
 754         }
 755     }
 756
 757   return 0;
 758 }
 759
 760 const char *
 761 _xdg_mime_cache_unalias_mime_type (const char *mime)
 762 {
 763   const char *lookup;
 764
 765   lookup = cache_alias_lookup (mime);
 766
 767   if (lookup)
 768     return lookup;
 769
 770   return mime;
 771 }
 772
 773 char **
 774 _xdg_mime_cache_list_mime_parents (const char *mime)
 775 {
 776   int i, j, p;
 777   char *all_parents[128]; /* we'll stop at 128 */
 778   char **result;
 779
 780   p = 0;
 781   for (i = 0; i < n_caches; i++)
 782     {
 783       XdgMimeCache *cache = caches[i];
 784
 785       xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
 786       xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 787
 788       for (j = 0; j < n_entries; j++)
 789         {
 790           xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * i);
 791           xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * i + 4);
 792
 793           if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
 794             {
 795               xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
 796
 797               for (j = 0; j < n_parents; j++)
 798                 all_parents[p++] = cache->buffer + parents_offset + 4 + 4 * j;
 799
 800               break;
 801             }
 802         }
 803     }
 804   all_parents[p++] = 0;
 805
 806   result = (char **) malloc (p * sizeof (char *));
 807   memcpy (result, all_parents, p * sizeof (char *));
 808
 809   return result;
 810 }
 811