xdgmime-source/src/xdgmime.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* xdgmime.c: XDG Mime Spec mime resolver.  Based on version 0.11 of the spec.
   3  *
   4  * More info can be found at http://www.freedesktop.org/standards/
   5  *
   6  * Copyright (C) 2003,2004  Red Hat, Inc.
   7  * Copyright (C) 2003,2004  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 "xdgmime.h"
  33 #include "xdgmimeint.h"
  34 #include "xdgmimeglob.h"
  35 #include "xdgmimemagic.h"
  36 #include "xdgmimealias.h"
  37 #include "xdgmimeicon.h"
  38 #include "xdgmimeparent.h"
  39 #include "xdgmimecache.h"
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <sys/stat.h>
  43 #include <sys/types.h>
  44 #include <sys/time.h>
  45 #include <unistd.h>
  46 #include <assert.h>
  47
  48 typedef struct XdgDirTimeList XdgDirTimeList;
  49 typedef struct XdgCallbackList XdgCallbackList;
  50
  51 static int need_reread = TRUE;
  52 static time_t last_stat_time = 0;
  53
  54 static XdgGlobHash *global_hash = NULL;
  55 static XdgMimeMagic *global_magic = NULL;
  56 static XdgAliasList *alias_list = NULL;
  57 static XdgParentList *parent_list = NULL;
  58 static XdgDirTimeList *dir_time_list = NULL;
  59 static XdgCallbackList *callback_list = NULL;
  60 static XdgIconList *icon_list = NULL;
  61 static XdgIconList *generic_icon_list = NULL;
  62
  63 XdgMimeCache **_caches = NULL;
  64 static int n_caches = 0;
  65
  66 const char xdg_mime_type_unknown[] = "application/octet-stream";
  67 const char xdg_mime_type_empty[] = "application/x-zerosize";
  68 const char xdg_mime_type_textplain[] = "text/plain";
  69
  70
  71 enum
  72 {
  73   XDG_CHECKED_UNCHECKED,
  74   XDG_CHECKED_VALID,
  75   XDG_CHECKED_INVALID
  76 };
  77
  78 struct XdgDirTimeList
  79 {
  80   time_t mtime;
  81   char *directory_name;
  82   int checked;
  83   XdgDirTimeList *next;
  84 };
  85
  86 struct XdgCallbackList
  87 {
  88   XdgCallbackList *next;
  89   XdgCallbackList *prev;
  90   int              callback_id;
  91   XdgMimeCallback  callback;
  92   void            *data;
  93   XdgMimeDestroy   destroy;
  94 };
  95
  96 /* Function called by xdg_run_command_on_dirs.  If it returns TRUE, further
  97  * directories aren't looked at */
  98 typedef int (*XdgDirectoryFunc) (const char *directory,
  99                                  void       *user_data);
 100
 101 static void
 102 xdg_dir_time_list_add (char   *file_name,
 103                        time_t  mtime)
 104 {
 105   XdgDirTimeList *list;
 106
 107   for (list = dir_time_list; list; list = list->next)
 108     {
 109       if (strcmp (list->directory_name, file_name) == 0)
 110         {
 111           free (file_name);
 112           return;
 113         }
 114     }
 115
 116   list = calloc (1, sizeof (XdgDirTimeList));
 117   list->checked = XDG_CHECKED_UNCHECKED;
 118   list->directory_name = file_name;
 119   list->mtime = mtime;
 120   list->next = dir_time_list;
 121   dir_time_list = list;
 122 }
 123
 124 static void
 125 xdg_dir_time_list_free (XdgDirTimeList *list)
 126 {
 127   XdgDirTimeList *next;
 128
 129   while (list)
 130     {
 131       next = list->next;
 132       free (list->directory_name);
 133       free (list);
 134       list = next;
 135     }
 136 }
 137
 138 static int
 139 xdg_mime_init_from_directory (const char *directory,
 140                               void       *user_data)
 141 {
 142   char *file_name;
 143   struct stat st;
 144
 145   assert (directory != NULL);
 146
 147   file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
 148   strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
 149   if (stat (file_name, &st) == 0)
 150     {
 151       XdgMimeCache *cache = _xdg_mime_cache_new_from_file (file_name);
 152
 153       if (cache != NULL)
 154         {
 155           xdg_dir_time_list_add (file_name, st.st_mtime);
 156
 157           _caches = realloc (_caches, sizeof (XdgMimeCache *) * (n_caches + 2));
 158           _caches[n_caches] = cache;
 159           _caches[n_caches + 1] = NULL;
 160           n_caches++;
 161
 162           return FALSE;
 163         }
 164     }
 165   free (file_name);
 166
 167   file_name = malloc (strlen (directory) + strlen ("/mime/globs2") + 1);
 168   strcpy (file_name, directory); strcat (file_name, "/mime/globs2");
 169   if (stat (file_name, &st) == 0)
 170     {
 171       _xdg_mime_glob_read_from_file (global_hash, file_name, TRUE);
 172       xdg_dir_time_list_add (file_name, st.st_mtime);
 173     }
 174   else
 175     {
 176       free (file_name);
 177       file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
 178       strcpy (file_name, directory); strcat (file_name, "/mime/globs");
 179       if (stat (file_name, &st) == 0)
 180         {
 181           _xdg_mime_glob_read_from_file (global_hash, file_name, FALSE);
 182           xdg_dir_time_list_add (file_name, st.st_mtime);
 183         }
 184       else
 185         {
 186           free (file_name);
 187         }
 188     }
 189
 190   file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
 191   strcpy (file_name, directory); strcat (file_name, "/mime/magic");
 192   if (stat (file_name, &st) == 0)
 193     {
 194       _xdg_mime_magic_read_from_file (global_magic, file_name);
 195       xdg_dir_time_list_add (file_name, st.st_mtime);
 196     }
 197   else
 198     {
 199       free (file_name);
 200     }
 201
 202   file_name = malloc (strlen (directory) + strlen ("/mime/aliases") + 1);
 203   strcpy (file_name, directory); strcat (file_name, "/mime/aliases");
 204   _xdg_mime_alias_read_from_file (alias_list, file_name);
 205   free (file_name);
 206
 207   file_name = malloc (strlen (directory) + strlen ("/mime/subclasses") + 1);
 208   strcpy (file_name, directory); strcat (file_name, "/mime/subclasses");
 209   _xdg_mime_parent_read_from_file (parent_list, file_name);
 210   free (file_name);
 211
 212   file_name = malloc (strlen (directory) + strlen ("/mime/icons") + 1);
 213   strcpy (file_name, directory); strcat (file_name, "/mime/icons");
 214   _xdg_mime_icon_read_from_file (icon_list, file_name);
 215   free (file_name);
 216
 217   file_name = malloc (strlen (directory) + strlen ("/mime/generic-icons") + 1);
 218   strcpy (file_name, directory); strcat (file_name, "/mime/generic-icons");
 219   _xdg_mime_icon_read_from_file (generic_icon_list, file_name);
 220   free (file_name);
 221
 222   return FALSE; /* Keep processing */
 223 }
 224
 225 /* Runs a command on all the directories in the search path */
 226 static void
 227 xdg_run_command_on_dirs (XdgDirectoryFunc  func,
 228                          void             *user_data)
 229 {
 230   const char *xdg_data_home;
 231   const char *xdg_data_dirs;
 232   const char *ptr;
 233
 234   xdg_data_home = getenv ("XDG_DATA_HOME");
 235   if (xdg_data_home)
 236     {
 237       if ((func) (xdg_data_home, user_data))
 238         return;
 239     }
 240   else
 241     {
 242       const char *home;
 243
 244       home = getenv ("HOME");
 245       if (home != NULL)
 246         {
 247           char *guessed_xdg_home;
 248           int stop_processing;
 249
 250           guessed_xdg_home = malloc (strlen (home) + strlen ("/.local/share/") + 1);
 251           strcpy (guessed_xdg_home, home);
 252           strcat (guessed_xdg_home, "/.local/share/");
 253           stop_processing = (func) (guessed_xdg_home, user_data);
 254           free (guessed_xdg_home);
 255
 256           if (stop_processing)
 257             return;
 258         }
 259     }
 260
 261   xdg_data_dirs = getenv ("XDG_DATA_DIRS");
 262   if (xdg_data_dirs == NULL)
 263     xdg_data_dirs = "/usr/local/share/:/usr/share/";
 264
 265   ptr = xdg_data_dirs;
 266
 267   while (*ptr != '\000')
 268     {
 269       const char *end_ptr;
 270       char *dir;
 271       int len;
 272       int stop_processing;
 273
 274       end_ptr = ptr;
 275       while (*end_ptr != ':' && *end_ptr != '\000')
 276         end_ptr ++;
 277
 278       if (end_ptr == ptr)
 279         {
 280           ptr++;
 281           continue;
 282         }
 283
 284       if (*end_ptr == ':')
 285         len = end_ptr - ptr;
 286       else
 287         len = end_ptr - ptr + 1;
 288       dir = malloc (len + 1);
 289       strncpy (dir, ptr, len);
 290       dir[len] = '\0';
 291       stop_processing = (func) (dir, user_data);
 292       free (dir);
 293
 294       if (stop_processing)
 295         return;
 296
 297       ptr = end_ptr;
 298     }
 299 }
 300
 301 /* Checks file_path to make sure it has the same mtime as last time it was
 302  * checked.  If it has a different mtime, or if the file doesn't exist, it
 303  * returns FALSE.
 304  *
 305  * FIXME: This doesn't protect against permission changes.
 306  */
 307 static int
 308 xdg_check_file (const char *file_path,
 309                 int        *exists)
 310 {
 311   struct stat st;
 312
 313   /* If the file exists */
 314   if (stat (file_path, &st) == 0)
 315     {
 316       XdgDirTimeList *list;
 317
 318       if (exists)
 319         *exists = TRUE;
 320
 321       for (list = dir_time_list; list; list = list->next)
 322         {
 323           if (! strcmp (list->directory_name, file_path))
 324             {
 325               if (st.st_mtime == list->mtime)
 326                 list->checked = XDG_CHECKED_VALID;
 327               else
 328                 list->checked = XDG_CHECKED_INVALID;
 329
 330               return (list->checked != XDG_CHECKED_VALID);
 331             }
 332         }
 333       return TRUE;
 334     }
 335
 336   if (exists)
 337     *exists = FALSE;
 338
 339   return FALSE;
 340 }
 341
 342 static int
 343 xdg_check_dir (const char *directory,
 344                void       *user_data)
 345 {
 346   int invalid, exists;
 347   char *file_name;
 348   int* invalid_dir_list = user_data;
 349
 350   assert (directory != NULL);
 351
 352   /* Check the mime.cache file */
 353   file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
 354   strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
 355   invalid = xdg_check_file (file_name, &exists);
 356   free (file_name);
 357   if (invalid)
 358     {
 359       *invalid_dir_list = TRUE;
 360       return TRUE;
 361     }
 362   else if (exists)
 363     {
 364       return FALSE;
 365     }
 366
 367   /* Check the globs file */
 368   file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
 369   strcpy (file_name, directory); strcat (file_name, "/mime/globs");
 370   invalid = xdg_check_file (file_name, NULL);
 371   free (file_name);
 372   if (invalid)
 373     {
 374       *invalid_dir_list = TRUE;
 375       return TRUE;
 376     }
 377
 378   /* Check the magic file */
 379   file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
 380   strcpy (file_name, directory); strcat (file_name, "/mime/magic");
 381   invalid = xdg_check_file (file_name, NULL);
 382   free (file_name);
 383   if (invalid)
 384     {
 385       *invalid_dir_list = TRUE;
 386       return TRUE;
 387     }
 388
 389   return FALSE; /* Keep processing */
 390 }
 391
 392 /* Walks through all the mime files stat()ing them to see if they've changed.
 393  * Returns TRUE if they have. */
 394 static int
 395 xdg_check_dirs (void)
 396 {
 397   XdgDirTimeList *list;
 398   int invalid_dir_list = FALSE;
 399
 400   for (list = dir_time_list; list; list = list->next)
 401     list->checked = XDG_CHECKED_UNCHECKED;
 402
 403   xdg_run_command_on_dirs (xdg_check_dir, &invalid_dir_list);
 404
 405   if (invalid_dir_list)
 406     return TRUE;
 407
 408   for (list = dir_time_list; list; list = list->next)
 409     {
 410       if (list->checked != XDG_CHECKED_VALID)
 411         return TRUE;
 412     }
 413
 414   return FALSE;
 415 }
 416
 417 /* We want to avoid stat()ing on every single mime call, so we only look for
 418  * newer files every 5 seconds.  This will return TRUE if we need to reread the
 419  * mime data from disk.
 420  */
 421 static int
 422 xdg_check_time_and_dirs (void)
 423 {
 424   struct timeval tv;
 425   time_t current_time;
 426   int retval = FALSE;
 427
 428   gettimeofday (&tv, NULL);
 429   current_time = tv.tv_sec;
 430
 431   if (current_time >= last_stat_time + 5)
 432     {
 433       retval = xdg_check_dirs ();
 434       last_stat_time = current_time;
 435     }
 436
 437   return retval;
 438 }
 439
 440 /* Called in every public function.  It reloads the hash function if need be.
 441  */
 442 static void
 443 xdg_mime_init (void)
 444 {
 445   if (xdg_check_time_and_dirs ())
 446     {
 447       xdg_mime_shutdown ();
 448     }
 449
 450   if (need_reread)
 451     {
 452       global_hash = _xdg_glob_hash_new ();
 453       global_magic = _xdg_mime_magic_new ();
 454       alias_list = _xdg_mime_alias_list_new ();
 455       parent_list = _xdg_mime_parent_list_new ();
 456       icon_list = _xdg_mime_icon_list_new ();
 457       generic_icon_list = _xdg_mime_icon_list_new ();
 458
 459       xdg_run_command_on_dirs (xdg_mime_init_from_directory, NULL);
 460
 461       need_reread = FALSE;
 462     }
 463 }
 464
 465 const char *
 466 xdg_mime_get_mime_type_for_data (const void *data,
 467                                  size_t      len,
 468                                  int        *result_prio)
 469 {
 470   const char *mime_type;
 471
 472   if (len == 0)
 473     {
 474       if (result_prio != NULL)
 475         *result_prio = 100;
 476       return XDG_MIME_TYPE_EMPTY;
 477     }
 478
 479   xdg_mime_init ();
 480
 481   if (_caches)
 482     mime_type = _xdg_mime_cache_get_mime_type_for_data (data, len, result_prio);
 483   else
 484     mime_type = _xdg_mime_magic_lookup_data (global_magic, data, len, result_prio, NULL, 0);
 485
 486   if (mime_type)
 487     return mime_type;
 488
 489   return _xdg_binary_or_text_fallback(data, len);
 490 }
 491
 492 const char *
 493 xdg_mime_get_mime_type_for_file (const char  *file_name,
 494                                  struct stat *statbuf)
 495 {
 496   const char *mime_type;
 497   /* currently, only a few globs occur twice, and none
 498    * more often, so 5 seems plenty.
 499    */
 500   const char *mime_types[5];
 501   FILE *file;
 502   unsigned char *data;
 503   int max_extent;
 504   int bytes_read;
 505   struct stat buf;
 506   const char *base_name;
 507   int n;
 508
 509   if (file_name == NULL)
 510     return NULL;
 511   if (! _xdg_utf8_validate (file_name))
 512     return NULL;
 513
 514   xdg_mime_init ();
 515
 516   if (_caches)
 517     return _xdg_mime_cache_get_mime_type_for_file (file_name, statbuf);
 518
 519   base_name = _xdg_get_base_name (file_name);
 520   n = _xdg_glob_hash_lookup_file_name (global_hash, base_name, mime_types, 5);
 521
 522   if (n == 1)
 523     return mime_types[0];
 524
 525   if (!statbuf)
 526     {
 527       if (stat (file_name, &buf) != 0)
 528         return XDG_MIME_TYPE_UNKNOWN;
 529
 530       statbuf = &buf;
 531     }
 532
 533   if (!S_ISREG (statbuf->st_mode))
 534     return XDG_MIME_TYPE_UNKNOWN;
 535
 536   /* FIXME: Need to make sure that max_extent isn't totally broken.  This could
 537    * be large and need getting from a stream instead of just reading it all
 538    * in. */
 539   max_extent = _xdg_mime_magic_get_buffer_extents (global_magic);
 540   data = malloc (max_extent);
 541   if (data == NULL)
 542     return XDG_MIME_TYPE_UNKNOWN;
 543
 544   file = fopen (file_name, "r");
 545   if (file == NULL)
 546     {
 547       free (data);
 548       return XDG_MIME_TYPE_UNKNOWN;
 549     }
 550
 551   bytes_read = fread (data, 1, max_extent, file);
 552   if (ferror (file))
 553     {
 554       free (data);
 555       fclose (file);
 556       return XDG_MIME_TYPE_UNKNOWN;
 557     }
 558
 559   mime_type = _xdg_mime_magic_lookup_data (global_magic, data, bytes_read, NULL,
 560                                            mime_types, n);
 561
 562   if (!mime_type)
 563     mime_type = _xdg_binary_or_text_fallback (data, bytes_read);
 564
 565   free (data);
 566   fclose (file);
 567
 568   return mime_type;
 569 }
 570
 571 const char *
 572 xdg_mime_get_mime_type_from_file_name (const char *file_name)
 573 {
 574   const char *mime_type;
 575
 576   xdg_mime_init ();
 577
 578   if (_caches)
 579     return _xdg_mime_cache_get_mime_type_from_file_name (file_name);
 580
 581   if (_xdg_glob_hash_lookup_file_name (global_hash, file_name, &mime_type, 1))
 582     return mime_type;
 583   else
 584     return XDG_MIME_TYPE_UNKNOWN;
 585 }
 586
 587 int
 588 xdg_mime_get_mime_types_from_file_name (const char *file_name,
 589                                         const char  *mime_types[],
 590                                         int          n_mime_types)
 591 {
 592   xdg_mime_init ();
 593
 594   if (_caches)
 595     return _xdg_mime_cache_get_mime_types_from_file_name (file_name, mime_types, n_mime_types);
 596
 597   return _xdg_glob_hash_lookup_file_name (global_hash, file_name, mime_types, n_mime_types);
 598 }
 599
 600 int
 601 xdg_mime_is_valid_mime_type (const char *mime_type)
 602 {
 603   /* FIXME: We should make this a better test
 604    */
 605   return _xdg_utf8_validate (mime_type);
 606 }
 607
 608 void
 609 xdg_mime_shutdown (void)
 610 {
 611   XdgCallbackList *list;
 612
 613   /* FIXME: Need to make this (and the whole library) thread safe */
 614   if (dir_time_list)
 615     {
 616       xdg_dir_time_list_free (dir_time_list);
 617       dir_time_list = NULL;
 618     }
 619
 620   if (global_hash)
 621     {
 622       _xdg_glob_hash_free (global_hash);
 623       global_hash = NULL;
 624     }
 625   if (global_magic)
 626     {
 627       _xdg_mime_magic_free (global_magic);
 628       global_magic = NULL;
 629     }
 630
 631   if (alias_list)
 632     {
 633       _xdg_mime_alias_list_free (alias_list);
 634       alias_list = NULL;
 635     }
 636
 637   if (parent_list)
 638     {
 639       _xdg_mime_parent_list_free (parent_list);
 640       parent_list = NULL;
 641     }
 642
 643   if (icon_list)
 644     {
 645       _xdg_mime_icon_list_free (icon_list);
 646       icon_list = NULL;
 647     }
 648
 649   if (generic_icon_list)
 650     {
 651       _xdg_mime_icon_list_free (generic_icon_list);
 652       generic_icon_list = NULL;
 653     }
 654
 655   if (_caches)
 656     {
 657       int i;
 658
 659       for (i = 0; i < n_caches; i++)
 660         _xdg_mime_cache_unref (_caches[i]);
 661       free (_caches);
 662       _caches = NULL;
 663       n_caches = 0;
 664     }
 665
 666   for (list = callback_list; list; list = list->next)
 667     (list->callback) (list->data);
 668
 669   need_reread = TRUE;
 670 }
 671
 672 int
 673 xdg_mime_get_max_buffer_extents (void)
 674 {
 675   xdg_mime_init ();
 676
 677   if (_caches)
 678     return _xdg_mime_cache_get_max_buffer_extents ();
 679
 680   return _xdg_mime_magic_get_buffer_extents (global_magic);
 681 }
 682
 683 const char *
 684 _xdg_mime_unalias_mime_type (const char *mime_type)
 685 {
 686   const char *lookup;
 687
 688   if (_caches)
 689     return _xdg_mime_cache_unalias_mime_type (mime_type);
 690
 691   if ((lookup = _xdg_mime_alias_list_lookup (alias_list, mime_type)) != NULL)
 692     return lookup;
 693
 694   return mime_type;
 695 }
 696
 697 const char *
 698 xdg_mime_unalias_mime_type (const char *mime_type)
 699 {
 700   xdg_mime_init ();
 701
 702   return _xdg_mime_unalias_mime_type (mime_type);
 703 }
 704
 705 int
 706 _xdg_mime_mime_type_equal (const char *mime_a,
 707                            const char *mime_b)
 708 {
 709   const char *unalias_a, *unalias_b;
 710
 711   unalias_a = _xdg_mime_unalias_mime_type (mime_a);
 712   unalias_b = _xdg_mime_unalias_mime_type (mime_b);
 713
 714   if (strcmp (unalias_a, unalias_b) == 0)
 715     return 1;
 716
 717   return 0;
 718 }
 719
 720 int
 721 xdg_mime_mime_type_equal (const char *mime_a,
 722                           const char *mime_b)
 723 {
 724   xdg_mime_init ();
 725
 726   return _xdg_mime_mime_type_equal (mime_a, mime_b);
 727 }
 728
 729 int
 730 xdg_mime_media_type_equal (const char *mime_a,
 731                            const char *mime_b)
 732 {
 733   char *sep;
 734
 735   sep = strchr (mime_a, '/');
 736
 737   if (sep && strncmp (mime_a, mime_b, sep - mime_a + 1) == 0)
 738     return 1;
 739
 740   return 0;
 741 }
 742
 743 #if 1
 744 static int
 745 ends_with (const char *str,
 746            const char *suffix)
 747 {
 748   int length;
 749   int suffix_length;
 750
 751   length = strlen (str);
 752   suffix_length = strlen (suffix);
 753   if (length < suffix_length)
 754     return 0;
 755
 756   if (strcmp (str + length - suffix_length, suffix) == 0)
 757     return 1;
 758
 759   return 0;
 760 }
 761
 762 static int
 763 xdg_mime_is_super_type (const char *mime)
 764 {
 765   return ends_with (mime, "/*");
 766 }
 767 #endif
 768
 769 int
 770 _xdg_mime_mime_type_subclass (const char *mime,
 771                               const char *base)
 772 {
 773   const char *umime, *ubase;
 774   const char **parents;
 775
 776   if (_caches)
 777     return _xdg_mime_cache_mime_type_subclass (mime, base);
 778
 779   umime = _xdg_mime_unalias_mime_type (mime);
 780   ubase = _xdg_mime_unalias_mime_type (base);
 781
 782   if (strcmp (umime, ubase) == 0)
 783     return 1;
 784
 785 #if 1
 786   /* Handle supertypes */
 787   if (xdg_mime_is_super_type (ubase) &&
 788       xdg_mime_media_type_equal (umime, ubase))
 789     return 1;
 790 #endif
 791
 792   /*  Handle special cases text/plain and application/octet-stream */
 793   if (strcmp (ubase, "text/plain") == 0 &&
 794       strncmp (umime, "text/", 5) == 0)
 795     return 1;
 796
 797   if (strcmp (ubase, "application/octet-stream") == 0 &&
 798       strncmp (umime, "inode/", 6) != 0)
 799     return 1;
 800
 801   parents = _xdg_mime_parent_list_lookup (parent_list, umime);
 802   for (; parents && *parents; parents++)
 803     {
 804       if (_xdg_mime_mime_type_subclass (*parents, ubase))
 805         return 1;
 806     }
 807
 808   return 0;
 809 }
 810
 811 int
 812 xdg_mime_mime_type_subclass (const char *mime,
 813                              const char *base)
 814 {
 815   xdg_mime_init ();
 816
 817   return _xdg_mime_mime_type_subclass (mime, base);
 818 }
 819
 820 char **
 821 xdg_mime_list_mime_parents (const char *mime)
 822 {
 823   const char **parents;
 824   char **result;
 825   int i, n;
 826
 827   if (_caches)
 828     return _xdg_mime_cache_list_mime_parents (mime);
 829
 830   parents = xdg_mime_get_mime_parents (mime);
 831
 832   if (!parents)
 833     return NULL;
 834
 835   for (i = 0; parents[i]; i++) ;
 836
 837   n = (i + 1) * sizeof (char *);
 838   result = (char **) malloc (n);
 839   memcpy (result, parents, n);
 840
 841   return result;
 842 }
 843
 844 const char **
 845 xdg_mime_get_mime_parents (const char *mime)
 846 {
 847   const char *umime;
 848
 849   xdg_mime_init ();
 850
 851   umime = _xdg_mime_unalias_mime_type (mime);
 852
 853   return _xdg_mime_parent_list_lookup (parent_list, umime);
 854 }
 855
 856 void
 857 xdg_mime_dump (void)
 858 {
 859   xdg_mime_init();
 860
 861   printf ("*** ALIASES ***\n\n");
 862   _xdg_mime_alias_list_dump (alias_list);
 863   printf ("\n*** PARENTS ***\n\n");
 864   _xdg_mime_parent_list_dump (parent_list);
 865   printf ("\n*** CACHE ***\n\n");
 866   _xdg_glob_hash_dump (global_hash);
 867   printf ("\n*** GLOBS ***\n\n");
 868   _xdg_glob_hash_dump (global_hash);
 869   printf ("\n*** GLOBS REVERSE TREE ***\n\n");
 870   _xdg_mime_cache_glob_dump ();
 871 }
 872
 873
 874 /* Registers a function to be called every time the mime database reloads its files
 875  */
 876 int
 877 xdg_mime_register_reload_callback (XdgMimeCallback  callback,
 878                                    void            *data,
 879                                    XdgMimeDestroy   destroy)
 880 {
 881   XdgCallbackList *list_el;
 882   static int callback_id = 1;
 883
 884   /* Make a new list element */
 885   list_el = calloc (1, sizeof (XdgCallbackList));
 886   list_el->callback_id = callback_id;
 887   list_el->callback = callback;
 888   list_el->data = data;
 889   list_el->destroy = destroy;
 890   list_el->next = callback_list;
 891   if (list_el->next)
 892     list_el->next->prev = list_el;
 893
 894   callback_list = list_el;
 895   callback_id ++;
 896
 897   return callback_id - 1;
 898 }
 899
 900 void
 901 xdg_mime_remove_callback (int callback_id)
 902 {
 903   XdgCallbackList *list;
 904
 905   for (list = callback_list; list; list = list->next)
 906     {
 907       if (list->callback_id == callback_id)
 908         {
 909           if (list->next)
 910             list->next = list->prev;
 911
 912           if (list->prev)
 913             list->prev->next = list->next;
 914           else
 915             callback_list = list->next;
 916
 917           /* invoke the destroy handler */
 918           (list->destroy) (list->data);
 919           free (list);
 920           return;
 921         }
 922     }
 923 }
 924
 925 const char *
 926 xdg_mime_get_icon (const char *mime)
 927 {
 928   xdg_mime_init ();
 929
 930   if (_caches)
 931     return _xdg_mime_cache_get_icon (mime);
 932
 933   return _xdg_mime_icon_list_lookup (icon_list, mime);
 934 }
 935
 936 const char *
 937 xdg_mime_get_generic_icon (const char *mime)
 938 {
 939   xdg_mime_init ();
 940
 941   if (_caches)
 942     return _xdg_mime_cache_get_generic_icon (mime);
 943
 944   return _xdg_mime_icon_list_lookup (generic_icon_list, mime);
 945 }