xdgmimecache.c File Reference

Go to the source code of this file.

Data Structures
struct	_XdgMimeCache
struct	MimeWeight

Functions
XdgMimeCache *	_xdg_mime_cache_ref (XdgMimeCache *cache)
void	_xdg_mime_cache_unref (XdgMimeCache *cache)
XdgMimeCache *	_xdg_mime_cache_new_from_file (const char *file_name)
int	_xdg_mime_cache_get_max_buffer_extents (void)
const char *	_xdg_mime_cache_get_mime_type_for_data (const void *data, size_t len, int *result_prio)
const char *	_xdg_mime_cache_get_mime_type_for_file (const char *file_name, struct stat *statbuf)
const char *	_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
int	_xdg_mime_cache_get_mime_types_from_file_name (const char *file_name, const char *mime_types[], int n_mime_types)
int	_xdg_mime_cache_mime_type_subclass (const char *mime, const char *base)
const char *	_xdg_mime_cache_unalias_mime_type (const char *mime)
char **	_xdg_mime_cache_list_mime_parents (const char *mime)
const char *	_xdg_mime_cache_get_generic_icon (const char *mime)
const char *	_xdg_mime_cache_get_icon (const char *mime)
void	_xdg_mime_cache_glob_dump (void)

Function Documentation

_xdg_mime_cache_get_generic_icon()

const char * _xdg_mime_cache_get_generic_icon

(

const char *

mime

)

Definition at line 1025 of file xdgmimecache.c.

{
  return cache_lookup_icon (mime, 36);
}

Referenced by xdg_mime_get_generic_icon().

_xdg_mime_cache_get_icon()

const char * _xdg_mime_cache_get_icon

(

const char *

mime

)

Definition at line 1031 of file xdgmimecache.c.

{
  return cache_lookup_icon (mime, 32);
}

Referenced by xdg_mime_get_icon().

_xdg_mime_cache_get_max_buffer_extents()

int _xdg_mime_cache_get_max_buffer_extents

(

void

)

Definition at line 644 of file xdgmimecache.c.

{
  xdg_uint32_t offset;
  xdg_uint32_t max_extent;
  int i;
 
  max_extent = 0;
  for (i = 0; _caches[i]; i++)
    {
      XdgMimeCache *cache = _caches[i];
 
      offset = GET_UINT32 (cache->buffer, 24);
      max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
    }
 
  return max_extent;
}

References _caches, and _XdgMimeCache::buffer.

Referenced by _xdg_mime_cache_get_mime_type_for_file(), and xdg_mime_get_max_buffer_extents().

_xdg_mime_cache_get_mime_type_for_data()

const char * _xdg_mime_cache_get_mime_type_for_data	(	const void *	data,
		size_t	len,
		int *	result_prio
	)

Definition at line 717 of file xdgmimecache.c.

{
  return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0);
}

Referenced by xdg_mime_get_mime_type_for_data().

_xdg_mime_cache_get_mime_type_for_file()

const char * _xdg_mime_cache_get_mime_type_for_file	(	const char *	file_name,
		struct stat *	statbuf
	)

Definition at line 725 of file xdgmimecache.c.

{
  const char *mime_type;
  const char *mime_types[10];
  FILE *file;
  unsigned char *data;
  int max_extent;
  int bytes_read;
  struct stat buf;
  const char *base_name;
  int n;
 
  if (file_name == NULL)
    return NULL;
 
  if (! _xdg_utf8_validate (file_name))
    return NULL;
 
  base_name = _xdg_get_base_name (file_name);
  n = cache_glob_lookup_file_name (base_name, mime_types, 10);
 
  if (n == 1)
    return mime_types[0];
 
  if (!statbuf)
    {
      if (stat (file_name, &buf) != 0)
    return XDG_MIME_TYPE_UNKNOWN;
 
      statbuf = &buf;
    }
 
  if (statbuf->st_size == 0)
    return XDG_MIME_TYPE_EMPTY;
 
  if (!S_ISREG (statbuf->st_mode))
    return XDG_MIME_TYPE_UNKNOWN;
 
  /* FIXME: Need to make sure that max_extent isn't totally broken.  This could
   * be large and need getting from a stream instead of just reading it all
   * in. */
  max_extent = _xdg_mime_cache_get_max_buffer_extents ();
  data = malloc (max_extent);
  if (data == NULL)
    return XDG_MIME_TYPE_UNKNOWN;
        
  file = fopen (file_name, "r");
  if (file == NULL)
    {
      free (data);
      return XDG_MIME_TYPE_UNKNOWN;
    }
 
  bytes_read = fread (data, 1, max_extent, file);
  if (ferror (file))
    {
      free (data);
      fclose (file);
      return XDG_MIME_TYPE_UNKNOWN;
    }
 
  mime_type = cache_get_mime_type_for_data (data, bytes_read, NULL,
                        mime_types, n);
 
  if (!mime_type)
    mime_type = _xdg_binary_or_text_fallback (data, bytes_read);
 
  free (data);
  fclose (file);
 
  return mime_type;
}

References _xdg_binary_or_text_fallback(), _xdg_get_base_name(), _xdg_mime_cache_get_max_buffer_extents(), and _xdg_utf8_validate().

Referenced by xdg_mime_get_mime_type_for_file().

_xdg_mime_cache_get_mime_type_from_file_name()

const char * _xdg_mime_cache_get_mime_type_from_file_name

(

const char *

file_name

)

Definition at line 800 of file xdgmimecache.c.

{
  const char *mime_type;
 
  if (cache_glob_lookup_file_name (file_name, &mime_type, 1))
    return mime_type;
  else
    return XDG_MIME_TYPE_UNKNOWN;
}

Referenced by xdg_mime_get_mime_type_from_file_name().

_xdg_mime_cache_get_mime_types_from_file_name()

int _xdg_mime_cache_get_mime_types_from_file_name	(	const char *	file_name,
		const char *	mime_types[],
		int	n_mime_types
	)

Definition at line 811 of file xdgmimecache.c.

{
  return cache_glob_lookup_file_name (file_name, mime_types, n_mime_types);
}

Referenced by xdg_mime_get_mime_types_from_file_name().

_xdg_mime_cache_glob_dump()

void _xdg_mime_cache_glob_dump

(

void

)

Definition at line 1065 of file xdgmimecache.c.

{
  int i, j;
  for (i = 0; _caches[i]; i++)
  {
    XdgMimeCache *cache = _caches[i];
    xdg_uint32_t list_offset;
    xdg_uint32_t n_entries;
    xdg_uint32_t offset;
    list_offset = GET_UINT32 (cache->buffer, 16);
    n_entries = GET_UINT32 (cache->buffer, list_offset);
    offset = GET_UINT32 (cache->buffer, list_offset + 4);
    for (j = 0; j < n_entries; j++)
        dump_glob_node (cache, offset + 20 * j, 0);
  }
}

References _caches, and _XdgMimeCache::buffer.

Referenced by xdg_mime_dump().

_xdg_mime_cache_list_mime_parents()

char ** _xdg_mime_cache_list_mime_parents

(

const char *

mime

)

Definition at line 931 of file xdgmimecache.c.

{
  int i, j, k, l, p;
  char *all_parents[128]; /* we'll stop at 128 */ 
  char **result;
 
  mime = xdg_mime_unalias_mime_type (mime);
 
  p = 0;
  for (i = 0; _caches[i]; i++)
    {
      XdgMimeCache *cache = _caches[i];
  
      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
 
      for (j = 0; j < n_entries; j++)
    {
      xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
      xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
 
      if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
        {
          xdg_uint32_t parent_mime_offset;
          xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
 
          for (k = 0; k < n_parents && p < 127; k++)
        {
          parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
 
          /* Don't add same parent multiple times.
           * This can happen for instance if the same type is listed in multiple directories
           */
          for (l = 0; l < p; l++)
            {
              if (strcmp (all_parents[l], cache->buffer + parent_mime_offset) == 0)
            break;
            }
 
          if (l == p)
            all_parents[p++] = cache->buffer + parent_mime_offset;
        }
 
          break;
        }
    }
    }
  all_parents[p++] = NULL;
  
  result = (char **) malloc (p * sizeof (char *));
  memcpy (result, all_parents, p * sizeof (char *));
 
  return result;
}

References _caches, _XdgMimeCache::buffer, and xdg_mime_unalias_mime_type().

Referenced by xdg_mime_list_mime_parents().

_xdg_mime_cache_mime_type_subclass()

int _xdg_mime_cache_mime_type_subclass	(	const char *	mime,
		const char *	base
	)

Definition at line 845 of file xdgmimecache.c.

{
  const char *umime, *ubase;
 
  int i, j, min, max, med, cmp;
  
  umime = _xdg_mime_cache_unalias_mime_type (mime);
  ubase = _xdg_mime_cache_unalias_mime_type (base);
 
  if (strcmp (umime, ubase) == 0)
    return 1;
 
  /* We really want to handle text/ * in GtkFileFilter, so we just
   * turn on the supertype matching
   */
#if 1
  /* Handle supertypes */
  if (is_super_type (ubase) &&
      xdg_mime_media_type_equal (umime, ubase))
    return 1;
#endif
 
  /*  Handle special cases text/plain and application/octet-stream */
  if (strcmp (ubase, "text/plain") == 0 && 
      strncmp (umime, "text/", 5) == 0)
    return 1;
 
  if (strcmp (ubase, "application/octet-stream") == 0 &&
      strncmp (umime, "inode/", 6) != 0)
    return 1;
 
  for (i = 0; _caches[i]; i++)
    {
      XdgMimeCache *cache = _caches[i];
      
      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
      xdg_uint32_t offset, n_parents, parent_offset;
 
      min = 0; 
      max = n_entries - 1;
      while (max >= min)
    {
      med = (min + max)/2;
      
      offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
      cmp = strcmp (cache->buffer + offset, umime);
      if (cmp < 0)
        min = med + 1;
      else if (cmp > 0)
        max = med - 1;
      else
        {
          offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
          n_parents = GET_UINT32 (cache->buffer, offset);
          
          for (j = 0; j < n_parents; j++)
        {
          parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
          if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
            return 1;
        }
 
          break;
        }
    }
    }
 
  return 0;
}

References _caches, _xdg_mime_cache_mime_type_subclass(), _xdg_mime_cache_unalias_mime_type(), _XdgMimeCache::buffer, and xdg_mime_media_type_equal().

Referenced by _xdg_mime_cache_mime_type_subclass(), and _xdg_mime_mime_type_subclass().

_xdg_mime_cache_new_from_file()

XdgMimeCache * _xdg_mime_cache_new_from_file

(

const char *

file_name

)

Definition at line 113 of file xdgmimecache.c.

{
  XdgMimeCache *cache = NULL;
 
#ifdef HAVE_MMAP
  int fd = -1;
  struct stat st;
  char *buffer = NULL;
  int minor;
 
  /* Open the file and map it into memory */
  do {
    fd = open (file_name, O_RDONLY|_O_BINARY, 0);
  } while (fd == -1 && errno == EINTR);
 
  if (fd < 0)
    return NULL;
  
  if (fstat (fd, &st) < 0 || st.st_size < 4)
    goto done;
 
  buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 
  if (buffer == MAP_FAILED)
    goto done;
 
  minor = GET_UINT16 (buffer, 2);
  /* Verify version */
  if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
      (minor < MINOR_VERSION_MIN ||
       minor > MINOR_VERSION_MAX))
    {
      munmap (buffer, st.st_size);
 
      goto done;
    }
  
  cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
  cache->minor = minor;
  cache->ref_count = 1;
  cache->buffer = buffer;
  cache->size = st.st_size;
 
 done:
  if (fd != -1)
    close (fd);
 
#endif  /* HAVE_MMAP */
 
  return cache;
}

References _XdgMimeCache::buffer, _XdgMimeCache::minor, _XdgMimeCache::ref_count, and _XdgMimeCache::size.

_xdg_mime_cache_ref()

XdgMimeCache * _xdg_mime_cache_ref

(

XdgMimeCache *

cache

)

Definition at line 92 of file xdgmimecache.c.

{
  cache->ref_count++;
  return cache;
}

References _XdgMimeCache::ref_count.

_xdg_mime_cache_unalias_mime_type()

const char * _xdg_mime_cache_unalias_mime_type

(

const char *

mime

)

Definition at line 918 of file xdgmimecache.c.

{
  const char *lookup;
  
  lookup = cache_alias_lookup (mime);
  
  if (lookup)
    return lookup;
  
  return mime;  
}

Referenced by _xdg_mime_cache_mime_type_subclass(), and _xdg_mime_unalias_mime_type().

_xdg_mime_cache_unref()

void _xdg_mime_cache_unref

(

XdgMimeCache *

cache

)

Definition at line 99 of file xdgmimecache.c.

{
  cache->ref_count--;
 
  if (cache->ref_count == 0)
    {
#ifdef HAVE_MMAP
      munmap (cache->buffer, cache->size);
#endif
      free (cache);
    }
}

References _XdgMimeCache::buffer, _XdgMimeCache::ref_count, and _XdgMimeCache::size.

Referenced by xdg_mime_shutdown().