mirror of
https://git.proxmox.com/git/libxdgmime-perl
synced 2025-07-27 08:10:09 +00:00
Merge commit 'cf31d981a600e46f3d3344be8f33f0813a909bb1' as 'xdgmime-source'
This commit is contained in:
Stoiko Ivanov
commit
3898ed6b16
4
xdgmime-source/.gitignore
vendored
Normal file
4
xdgmime-source/.gitignore
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
src/print-mime-data
|
||||
src/test-mime
|
||||
src/test-mime-data
|
||||
src/*.o
|
||||
29
xdgmime-source/.gitlab-ci.yml
Normal file
29
xdgmime-source/.gitlab-ci.yml
Normal file
@ -0,0 +1,29 @@
|
||||
image: fedora:rawhide
|
||||
|
||||
variables:
|
||||
DEPENDENCIES: gcc
|
||||
gcc-c++
|
||||
glibc-devel
|
||||
make
|
||||
libxml2-devel
|
||||
glib2-devel
|
||||
gettext
|
||||
git
|
||||
itstool
|
||||
xmlto
|
||||
findutils
|
||||
gettext-devel
|
||||
meson
|
||||
|
||||
build:meson:
|
||||
before_script:
|
||||
- dnf update -y --nogpgcheck
|
||||
- dnf install -y --nogpgcheck $DEPENDENCIES
|
||||
script:
|
||||
- make
|
||||
|
||||
# Compile shared-mime-info
|
||||
- git clone https://gitlab.freedesktop.org/xdg/shared-mime-info.git
|
||||
- cd shared-mime-info
|
||||
- meson _build
|
||||
- ninja -C _build test
|
||||
741
xdgmime-source/ChangeLog
Normal file
741
xdgmime-source/ChangeLog
Normal file
@ -0,0 +1,741 @@
|
||||
2009-10-06 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_lookup_file_name):
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_lookup_file_name):
|
||||
Remove unused variables
|
||||
|
||||
2009-10-02 Alexander Larsson <alexl@redhat.com>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_get_icon):
|
||||
* src/xdgmimecache.c: (_xdg_mime_cache_get_icon):
|
||||
Fix mime lookup order, imported from glib copy.
|
||||
Fixes gnome bug #555711
|
||||
|
||||
2009-10-02 Alexander Larsson <alexl@redhat.com>
|
||||
|
||||
* src/xdgmimecache.c: (cache_magic_matchlet_compare_to_data):
|
||||
Use correct bounds check for magic ranges
|
||||
|
||||
2009-10-02 Alexander Larsson <alexl@redhat.com>
|
||||
|
||||
* src/xdgmimecache.c: (cache_glob_lookup_literal),
|
||||
(cache_glob_lookup_fnmatch), (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (ascii_tolower),
|
||||
(cache_glob_lookup_file_name):
|
||||
* src/xdgmimeglob.c: (_xdg_glob_list_append),
|
||||
(_xdg_glob_hash_insert_ucs4), (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name), (ascii_tolower),
|
||||
(_xdg_glob_hash_lookup_file_name), (_xdg_glob_hash_append_glob):
|
||||
Support the case-sensitive attribute
|
||||
|
||||
2009-10-02 Alexander Larsson <alexl@redhat.com>
|
||||
|
||||
* src/xdgmimecache.c: (_xdg_mime_cache_new_from_file):
|
||||
Support reading cache files with minor number 2
|
||||
|
||||
2009-10-02 Alexander Larsson <alexl@redhat.com>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_init_from_directory):
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_append_glob),
|
||||
(_xdg_mime_glob_read_from_file):
|
||||
* src/xdgmimeglob.h:
|
||||
Read the new updated glob2 format with flags
|
||||
|
||||
2009-03-09 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/test-mime.c (test_one_icon): Fix possible
|
||||
crash when xdg_mime_get_icon() returns NULL, spotted by
|
||||
Sanel Zukan <sanelz@gmail.com> (Closes: #20555)
|
||||
|
||||
2009-01-08 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_shutdown): Patch from
|
||||
Carlos Garcia Campos <carlosgc@gnome.org> to
|
||||
fix a memory leak on shutdown (Closes: #16972)
|
||||
|
||||
2008-09-27 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_dir_time_list_add): Patch from
|
||||
Christian Persch, closing a memleak (Closes: #17464)
|
||||
|
||||
2008-06-09 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_node_lookup_suffix):
|
||||
Patch by Matthias Clasen <mclasen@redhat.com> to implement
|
||||
the compact suffix tree
|
||||
|
||||
2008-06-05 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_node_lookup_suffix):
|
||||
Patch by Matthias Clasen <mclasen@redhat.com> to fix reading
|
||||
the suffix lookup (wrong offsets when reading the mime-type
|
||||
offset and weight)
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_dump):
|
||||
* src/xdgmimecache.c (cache_glob_node_lookup_suffix),
|
||||
(dump_glob_node), (_xdg_mime_cache_glob_dump):
|
||||
* src/xdgmimecache.h: dumping code for the suffix reverse tree
|
||||
from Matthias Clasen <mclasen@redhat.com>, and hooked up in
|
||||
xdg_mime_dump, init the cache in xdg_mime_dump() in case
|
||||
it's the only xdgmime function called
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c: Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Bump the cache version to 1.1
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/Makefile:
|
||||
* src/test-mime.c (test_one_icon), (test_icons), (main):
|
||||
* src/xdgmime.c (xdg_mime_init_from_directory), (xdg_mime_init),
|
||||
(xdg_mime_get_icon), (xdg_mime_get_generic_icon):
|
||||
* src/xdgmime.h:
|
||||
* src/xdgmimecache.c (cache_lookup_icon),
|
||||
(_xdg_mime_cache_get_generic_icon), (_xdg_mime_cache_get_icon):
|
||||
* src/xdgmimecache.h:
|
||||
* src/xdgmimeicon.c:
|
||||
* src/xdgmimeicon.h: Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Add icon and generic-icon support
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_lookup_file_name):
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_lookup_file_name):
|
||||
* src/xdgmimeint.c (_xdg_convert_to_ucs4), (_xdg_reverse_ucs4):
|
||||
* src/xdgmimeint.h: Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Cleanups
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (to_ucs4),
|
||||
(cache_glob_lookup_file_name):
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_insert_ucs4), (to_ucs4),
|
||||
(ucs4_reverse), (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name),
|
||||
(_xdg_glob_hash_lookup_file_name): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Use reverted suffix trees
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/test-mime.c (test_subclassing), (test_one_match),
|
||||
(test_matches), (main): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Add some glob tests
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_dump): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Include globs in the dump
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_init_from_directory):
|
||||
* src/xdgmimecache.c (cache_glob_lookup_literal),
|
||||
(cache_glob_lookup_fnmatch), (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (find_stopchars),
|
||||
(compare_mime_weight), (cache_glob_lookup_file_name),
|
||||
(_xdg_mime_cache_get_mime_type_for_file):
|
||||
* src/xdgmimeglob.c (_xdg_glob_list_append),
|
||||
(_xdg_glob_hash_node_dump), (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name), (compare_mime_weight),
|
||||
(_xdg_glob_hash_lookup_file_name), (_xdg_glob_determine_type),
|
||||
(_xdg_glob_hash_append_glob), (_xdg_glob_hash_dump),
|
||||
(_xdg_mime_glob_read_from_file):
|
||||
* src/xdgmimeglob.h: Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: Implement glob weights
|
||||
|
||||
2008-06-03 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name), (_xdg_glob_determine_type),
|
||||
(_xdg_mime_glob_read_from_file): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com>: remove dead code and some trivial cleanups
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/Makefile: Remove test-mime-data on clean
|
||||
* src/test-mime-data.c (test_by_data): Fix for API changes below
|
||||
|
||||
* src/xdgmime.c (xdg_dir_time_list_add),
|
||||
(xdg_mime_init_from_directory), (xdg_check_file), (xdg_check_dir),
|
||||
(xdg_mime_get_mime_type_for_data),
|
||||
(xdg_mime_get_mime_type_for_file),
|
||||
(xdg_mime_get_mime_type_from_file_name),
|
||||
(xdg_mime_get_mime_types_from_file_name), (xdg_mime_shutdown),
|
||||
(xdg_mime_get_max_buffer_extents), (_xdg_mime_unalias_mime_type),
|
||||
(xdg_mime_media_type_equal), (_xdg_mime_mime_type_subclass),
|
||||
(xdg_mime_list_mime_parents):
|
||||
* src/xdgmime.h:
|
||||
* src/xdgmimealias.h:
|
||||
* src/xdgmimecache.c (cache_magic_lookup_data),
|
||||
(cache_alias_lookup), (cache_glob_lookup_literal),
|
||||
(cache_glob_lookup_fnmatch), (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (find_stopchars),
|
||||
(_xdg_mime_cache_get_max_buffer_extents),
|
||||
(cache_get_mime_type_for_data),
|
||||
(_xdg_mime_cache_get_mime_type_for_data),
|
||||
(_xdg_mime_cache_get_mime_type_for_file),
|
||||
(_xdg_mime_cache_get_mime_type_from_file_name),
|
||||
(_xdg_mime_cache_get_mime_types_from_file_name),
|
||||
(_xdg_mime_cache_mime_type_subclass),
|
||||
(_xdg_mime_cache_list_mime_parents):
|
||||
* src/xdgmimecache.h:
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_node_lookup_file_name):
|
||||
* src/xdgmimeglob.h:
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_parse_magic_line),
|
||||
(_xdg_mime_magic_lookup_data):
|
||||
* src/xdgmimemagic.h:
|
||||
* src/xdgmimeparent.h:
|
||||
|
||||
Merge from downstream changes in GIO/GTK+:
|
||||
- Rename _xdg_mime_caches to _caches and make sure it's not exported
|
||||
- Rework the timestamp checking code
|
||||
to protect against duplicate directories in XDG_DATA_DIRS.
|
||||
- Fix a thinko that leads to constantly reloading
|
||||
the mime data if a mime.cache is present.
|
||||
- Support more than 2 duplicate globs
|
||||
- Add xdg_mime_get_mime_types_from_file_name()
|
||||
- xdg_mime_media_type_equal() doesn't require an _init after all
|
||||
- Handle super-types in _xdg_mime_mime_type_subclass()
|
||||
- Make cache_get_mime_type_for_data() and
|
||||
_xdg_mime_magic_lookup_data() return the priority of the
|
||||
matching mime-type
|
||||
- Fix _xdg_mime_cache_list_mime_parents returning duplicate parents in
|
||||
some cases
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_init_from_directory), (xdg_mime_dump):
|
||||
* src/xdgmimecache.c (cache_glob_lookup_literal),
|
||||
(cache_glob_lookup_fnmatch), (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (find_stopchars),
|
||||
(cache_glob_lookup_file_name),
|
||||
(_xdg_mime_cache_get_mime_type_for_file):
|
||||
* src/xdgmimeglob.c (_xdg_glob_list_append),
|
||||
(_xdg_glob_list_prepend), (_xdg_glob_hash_node_dump),
|
||||
(_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name),
|
||||
(_xdg_glob_hash_lookup_file_name), (_xdg_glob_determine_type),
|
||||
(_xdg_glob_hash_append_glob), (_xdg_glob_hash_dump),
|
||||
(_xdg_mime_glob_read_from_file):
|
||||
* src/xdgmimeglob.h: Revert previous patches, we need to rebase first
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/test-mime.c (test_subclassing), (test_one_match),
|
||||
(test_matches), (main): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com> to add some globs tests to the
|
||||
test program
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_dump): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com> to include globs output in the dump
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_init_from_directory):
|
||||
* src/xdgmimecache.c (cache_glob_lookup_literal),
|
||||
(cache_glob_lookup_fnmatch), (cache_glob_node_lookup_suffix),
|
||||
(cache_glob_lookup_suffix), (find_stopchars),
|
||||
(compare_mime_weight), (cache_glob_lookup_file_name),
|
||||
(_xdg_mime_cache_get_mime_type_for_file):
|
||||
* src/xdgmimeglob.c (_xdg_glob_list_append),
|
||||
(_xdg_glob_hash_node_dump), (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name), (compare_mime_weight),
|
||||
(_xdg_glob_hash_lookup_file_name), (_xdg_glob_determine_type),
|
||||
(_xdg_glob_hash_append_glob), (_xdg_glob_hash_dump),
|
||||
(_xdg_mime_glob_read_from_file):
|
||||
* src/xdgmimeglob.h: Patch from Matthias Clasen <mclasen@redhat.com>
|
||||
to implement glob weights
|
||||
|
||||
2008-06-02 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_node_lookup_file_name), (_xdg_glob_determine_type),
|
||||
(_xdg_mime_glob_read_from_file): Patch from Matthias Clasen
|
||||
<mclasen@redhat.com> to remove dead code and do some trivial changes
|
||||
|
||||
2008-04-18 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/xdgmimecache.c (cache_magic_lookup_data),
|
||||
(_xdg_mime_cache_mime_type_subclass): Fix possible crasher when
|
||||
XDG_DATA_DIRS contains the same directory twice, patch by Joe Shaw
|
||||
<joeshaw@novell.com> (#12512)
|
||||
|
||||
Make _xdg_mime_cache_mime_type_subclass use the internal version of
|
||||
xdg_mime_media_type_equal(), spotted by Federico Mena-Quintero
|
||||
<federico@ximian.com>
|
||||
|
||||
2008-04-10 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/test-mime-data.c (main): Only error out when
|
||||
the number of errors is different from the number of expected errors,
|
||||
or when there's unexpected success
|
||||
|
||||
2007-08-28 Bastien Nocera <hadess@hadess.net>
|
||||
|
||||
* src/.cvsignore:
|
||||
* src/Makefile:
|
||||
* src/test-mime-data.c: Add test-mime-data test program from
|
||||
Matthias Clasen <mclasen@redhat.com> (Closes: #5210)
|
||||
|
||||
2007-06-04 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime*.[ch]: Rename _caches to _xdg_mime_caches. Also
|
||||
namespace all reserved symbols that are declared in headers using
|
||||
XDG_RESERVED_ENTRY(), #7074 and #11124. Thanks to Yevgen Muntyan
|
||||
<muntyan@tamu.edu> and Joe Marcus Clarke <marcus@freebsd.org>.
|
||||
|
||||
2007-06-02 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime.[ch]: Move xdg_mime_type_unknown to .rodata.
|
||||
* src/xdgmime.h: Add XDG_ENTRY() entry for xdg_mime_dump.
|
||||
GTK+ resync.
|
||||
|
||||
* src/xdgmime.c: (_xdg_mime_alias_list_lookup): Initialize mime_type
|
||||
to NULL instead of 0, GNOME #341812. Thanks to Kjartan Maraas
|
||||
<kmaraas@gnome.org>.
|
||||
|
||||
* src/xdgmime.[ch]: (xdg_mime_media_type_equal),
|
||||
(_xdg_mime_media_type_equal): Add private version of
|
||||
xdg_mime_media_type_equal that doesn't call xdg_mime_init(), use it in
|
||||
_xdg_mime_mime_type_subclass.
|
||||
|
||||
2007-06-02 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: Fallback to getc() if getc_unlocked() is not
|
||||
available, GNOME #381499. Thanks to Paul <ephraim_owns@hotmail.com>.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_get_mime_type_for_file): Only request two
|
||||
MIME types from cache.
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_dump): Dump cache.
|
||||
|
||||
* src/xdgmimecache.c: Warn if building without MMAP support.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_lookup_cache_for_file), (xdg_check_dir):
|
||||
Fix constant re-creation of memory MIME cache, #7495.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_node_lookup_file_name): Don't
|
||||
return NULL MIME types, #5241.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_shutdown): Fix cache variable name from last
|
||||
commit.
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_unalias_mime_type), (xdg_mime_mime_type_equal):
|
||||
* src/xdgmime.h:
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_lookup_data):
|
||||
Define and use private versions of functions that may lead to an
|
||||
xdg_mime_init() call and thus to an invalid cache, and a crash - #6824.
|
||||
Thanks to Joe Shaw <joeshaw@novell.com>.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_shutdown): Free caches, #7496.
|
||||
Thanks to Yevgen Muntyan <muntyan@tamu.edu>.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimecache.c: (cache_glob_node_lookup_suffix): Don't return
|
||||
MIME types if cache suffix lookup returns empty string, #9544.
|
||||
Thanks to Yevgen Muntyan <muntyan@tamu.edu>.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_lookup_data): Fix issue where
|
||||
MIME type was not detected when two MIME types with parent
|
||||
relationship match and have equal priority, and child
|
||||
was found before parent in cache, #9242.
|
||||
Thanks to Tom Parker <freedesktop@tevp.net>.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimecache.c: (_xdg_mime_cache_list_mime_parents): Fix
|
||||
several problems with this function, #9560. Thanks to Yevgen Muntyan.
|
||||
|
||||
2007-06-01 Christian Neumair <cneumair@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: Don't declare errno, fixes build on Dragonfly
|
||||
BSD, GNOME #336382.
|
||||
|
||||
2006-07-13 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_parse_magic_line):
|
||||
Only declare 'i' #if LITTLE_ENDIAN. Partially fixes GNOME #340277.
|
||||
Thanks to James Andrewartha.
|
||||
|
||||
2006-03-02 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_insert_text),
|
||||
(_xdg_glob_hash_append_glob): Don't strdup the MIME type when passing
|
||||
it to _xdg_glob_hash_insert_text, but let the function itself figure
|
||||
out whether string duplication is needed. Fixes #5993.
|
||||
Thanks to Martin Wehner.
|
||||
|
||||
2006-02-25 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_lookup_data): Make
|
||||
priority equality check more robust so that it works for three or more
|
||||
matches. Also allow matchlets with 0 priority.
|
||||
|
||||
2006-02-19 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_lookup_data): When two
|
||||
unrelated MIME types with equal priorities match, don't assume one of
|
||||
them matches.
|
||||
http://bugzilla.gnome.org/show_bug.cgi?id=331719
|
||||
|
||||
2006-01-03 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_lookup_data): Also consider
|
||||
match priority for the returned MIME type.
|
||||
|
||||
2005-12-01 Christian Neumair <chris@gnome-de.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_get_mime_type_from_file_name):
|
||||
* src/xdgmimecache.c: (_xdg_mime_cache_get_mime_type_from_file_name):
|
||||
Return XDG_MIME_TYPE_UNKNOWN if multiple MIME types match a simple
|
||||
pattern.
|
||||
|
||||
2005-12-01 Matthias Clasen <mclasen@redhat.com>
|
||||
|
||||
* src/xdgmimecache.h:
|
||||
* src/xdgmimecache.c (_xdg_mime_cache_get_mime_type_for_file):
|
||||
Allow passing in a struct stat * to avoid re-stat()ing.
|
||||
Forgotten commit from an earlier entry.
|
||||
|
||||
* src/xdgmimecache.c (cache_glob_lookup_literal):
|
||||
(cache_glob_lookup_fnmatch):
|
||||
(cache_glob_node_lookup_suffix): Change these functions to
|
||||
allow returning more than one mime type if identical globs
|
||||
match.
|
||||
|
||||
* src/xdgmimemagic.h:
|
||||
* src/xdgmimeglob.h:
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_lookup_data):
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_lookup_file_name):
|
||||
Change these functions to allow returning more than one
|
||||
mime type if identical globs match.
|
||||
|
||||
* src/xdgmimecache.c (_xdg_mime_cache_get_mime_type_for_file):
|
||||
* src/xdgmime.c (xdg_mime_get_mime_type_for_file):
|
||||
If multiple identical globs match, use magic to disambiguate.
|
||||
|
||||
2005-11-04 Matthias Clasen <mclasen@redhat.com>
|
||||
|
||||
* xdgmime.c (xdg_mime_list_mime_parents): Prevent
|
||||
a segfault.
|
||||
|
||||
2005-10-18 Matthias Clasen <mclasen@redhat.com>
|
||||
|
||||
* src/xdgmime.c:
|
||||
* src/xdgmimecache.h:
|
||||
* src/xdgmimecache.c: Make the array of caches NULL-terminated
|
||||
and rename it to _caches. (#4011)
|
||||
|
||||
* src/xdgmime.h:
|
||||
* src/xdgmime.c: Add a struct statbuf * argument to
|
||||
xdg_mime_get_mime_type_for_file(). (#3529)
|
||||
|
||||
* src/test-mime.c: Adjust callers. Add License.
|
||||
|
||||
* src/xdgmimecache.c: Make magic comparisons work correctly.
|
||||
|
||||
Thu Jun 9 23:55:25 2005 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_init_from_directory): patch from
|
||||
federico to realloc the right size, #3506
|
||||
|
||||
2005-04-17 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimeint.c: fix gcc4 signedness warning
|
||||
|
||||
2005-04-17 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_matchlet_compare_to_data),
|
||||
(_xdg_mime_magic_matchlet_compare_level),
|
||||
(_xdg_mime_magic_lookup_data): when magic patterns matches, check if
|
||||
there aren't subtypes with matching patterns too, and if so, favour
|
||||
the subtype over the parent type, should fix #2686
|
||||
|
||||
2005-04-16 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_init_from_directory): fix leak when
|
||||
mime.cache doesn't exist
|
||||
|
||||
2005-04-16 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/test-mime.c: (main): disabled call to xdg_mime_dump for now
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_matchlet_compare_to_data):
|
||||
fixed off by 1 error when handling offsets, fixes bug #2050 and
|
||||
partly bug #2359
|
||||
|
||||
Fri Apr 8 23:37:33 2005 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmimecache.c: Actually add the file. Also, patch from
|
||||
Matthias Clasen <mclasen@redhat.com> to fix small bugs, #2939
|
||||
|
||||
Fri Apr 1 14:59:43 2005 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmimecache.c: Patch from Matthias Clasen to mmap the
|
||||
cached xdg file.
|
||||
|
||||
Mon Mar 28 13:58:32 2005 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_insert_text): patch from
|
||||
Matthias Clasen to handle globs that don't have '.' chars in
|
||||
them. As an example 'foo~' should match '*~'
|
||||
|
||||
Mon Mar 21 13:16:12 2005 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_shutdown): fix from Axel Liljencrantz
|
||||
<f97-ali@nada.kth.se> to free parent_list in shutdown.
|
||||
|
||||
2005-01-10 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_lookup_file_name): make previous
|
||||
commit actually work...
|
||||
|
||||
2005-01-10 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_lookup_file_name): don't get
|
||||
confused by multiple dots in filenames when doing extension matching
|
||||
|
||||
2004-12-13 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmime.h:
|
||||
|
||||
wrap new API in XDG_ENTRY()
|
||||
|
||||
2004-12-13 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_lookup_file_name):
|
||||
|
||||
Do not assume the filename is UTF8. We just need to look
|
||||
for the dot which is ASCII.
|
||||
|
||||
2004-12-09 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeint.h:
|
||||
|
||||
Remove spacings I introduced by mistake
|
||||
|
||||
2004-12-09 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimealias.c: (_xdg_mime_alias_read_from_file):
|
||||
* src/xdgmimeint.c: (_xdg_ucs4_to_lower):
|
||||
* src/xdgmimeint.h:
|
||||
* src/xdgmimeparent.c: (_xdg_mime_parent_read_from_file):
|
||||
|
||||
Check in Mariano Suárez-Alvarez <msuarezalvarez@arnet.com.ar> patch
|
||||
for GNOME bug #160838.
|
||||
|
||||
2004-12-09 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_node_lookup_file_name):
|
||||
* src/xdgmimeint.c: (_xdg_ucs4_to_lower):
|
||||
* src/xdgmimeint.h:
|
||||
|
||||
Follow the freedesktop spec about case sensitiveness. Fix #732
|
||||
|
||||
2004-12-08 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_mime_glob_read_from_file): backing out
|
||||
"fix" for bug #1048 since it frees memory that shouldn't be freed.
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_read_from_file):
|
||||
|
||||
Check that fread succeeded reading all chars. Fix #1049
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmime.c:
|
||||
* src/xdgmimealias.c:
|
||||
* src/xdgmimeglob.c:
|
||||
* src/xdgmimeint.c:
|
||||
* src/xdgmimemagic.c:
|
||||
* src/xdgmimeparent.c:
|
||||
|
||||
Include config.h. Fix #913
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimealias.c: (_xdg_mime_alias_list_lookup):
|
||||
|
||||
Fix a typo
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmime.c: (xdg_mime_unalias_mime_type),
|
||||
(xdg_mime_mime_type_equal), (xdg_mime_mime_type_subclass),
|
||||
(xdg_mime_get_mime_parents):
|
||||
* src/xdgmime.h:
|
||||
|
||||
Add apis to get parents and to unalias mime type
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimealias.c: (_xdg_mime_alias_list_lookup):
|
||||
* src/xdgmimeparent.c: (_xdg_mime_parent_list_lookup):
|
||||
|
||||
Protect against stupid bsearch() implementations. (#1961,
|
||||
Morten Welinder)
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeparent.c: (_xdg_mime_parent_read_from_file):
|
||||
|
||||
Initialize the parent field of the newly allocate list
|
||||
entry. (#1916, Alex Larsson)
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_mime_glob_read_from_file):
|
||||
|
||||
Patch from Matthias Clasen <mclasen@redhat.com> to fix
|
||||
a mem leak. Bug #1048
|
||||
|
||||
2004-12-08 Marco Pesenti Gritti <marco@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.h:
|
||||
|
||||
Patch from Michael.Wilson@bull.net to fix compile error on AIX
|
||||
|
||||
Sun Nov 7 02:25:21 2004 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmime.h: Patch from Matthias Clasen <mclasen@redhat.com>
|
||||
to add alias and inheritance support.
|
||||
|
||||
2004-09-16 Christophe Fergeau <teuf@gnome.org>
|
||||
|
||||
* src/xdgmimeglob.c: (_xdg_glob_hash_free_nodes):
|
||||
* src/xdgmimemagic.c: (_xdg_mime_magic_free): fix memory leaks,
|
||||
fixes http://bugzilla.gnome.org/show_bug.cgi?id=152771 and
|
||||
http://bugzilla.gnome.org/show_bug.cgi?id=152768
|
||||
|
||||
Mon Jul 19 00:23:00 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_register_reload_callback): register a
|
||||
callback when we reload MIME data.
|
||||
|
||||
* src/xdgmime.c (xdg_mime_remove_callback): Add capability to
|
||||
remove callback.
|
||||
|
||||
Sun Jul 18 20:56:22 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_shutdown):
|
||||
(xdg_mime_init): reread data when it changes on disk.
|
||||
|
||||
Thu May 27 16:18:14 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.h: move xdg_mime_shutdown into the XDG_ENTRY guard.
|
||||
|
||||
Thu May 27 15:02:13 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_read_magic_file): patch from
|
||||
Hongli Lai <h.lai@chello.nl> to catch magic files that don't end
|
||||
with a '\n'.
|
||||
|
||||
Fri Apr 30 11:56:01 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_read_a_number): make the
|
||||
buffer the right size. Reported by Morten Welinder, #136323
|
||||
|
||||
Sun Mar 21 23:56:46 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c: Patch from Arjan van de Ven
|
||||
<arjanv@redhat.com> to do s/fgetc/getc_unlocked/g.
|
||||
|
||||
Wed Mar 10 22:28:41 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_read_a_number): fix usage of
|
||||
isdigit. Reported by Morten Welinder, #136323
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_read_magic_file): patch from
|
||||
Christophe Fergeau to reverse the order of the matchlet before
|
||||
adding it to the list.
|
||||
|
||||
* src/xdgmimeint.h (_xdg_utf8_skip): patch from Alexander Larsson
|
||||
to make extern.
|
||||
|
||||
Wed Jan 21 09:29:41 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_insert_match): dropped
|
||||
patches. Fix.
|
||||
|
||||
* src/xdgmimeglob.c (_xdg_glob_hash_free_nodes): dropped patches.
|
||||
Fix.
|
||||
|
||||
Tue Jan 20 14:55:39 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.h (XDG_MIME_TYPE_UNKNOWN): move the definition so
|
||||
that it catches the XDG_ENTRY mangling.
|
||||
|
||||
* src/xdgmimemagic.c: make some functions static
|
||||
|
||||
Tue Jan 20 14:34:26 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_get_max_buffer_extents): add function so
|
||||
that it's easy to get the max buffer extents.
|
||||
|
||||
Tue Jan 20 12:55:55 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/Makefile: Test prefix code
|
||||
|
||||
* src/xdgmime*.h: Fully use the prefix code
|
||||
|
||||
* src/xdgmime.c: finish the syncing from both GTK+ and gnome-vfs.
|
||||
|
||||
Tue Jan 13 16:21:04 2004 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* src/xdgmime.[ch] (XDG_MIME_TYPE_UNKNOWN): make an extern const
|
||||
char * so that comparisons can work.
|
||||
|
||||
* src/xdgmimeint.c (_xdg_utf8_to_ucs4): patch from Dave Jones
|
||||
<davej@redhat.com> to make operations more explicit.
|
||||
|
||||
Tue Oct 28 15:09:06 2003 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* README: Add a readme, and clarify the licensing terms of the
|
||||
software.
|
||||
|
||||
Tue Oct 28 14:47:37 2003 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmime.c (xdg_mime_shutdown): implement shutdown. This
|
||||
frees all memory and resets to an uninitialized state as best as
|
||||
possible.
|
||||
|
||||
Mon Oct 27 11:45:58 2003 Jonathan Blandford <jrb@redhat.com>
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_read_a_number): strtol
|
||||
returns a long, not an int. Thanks to Manish Singh for pointing
|
||||
this out.
|
||||
|
||||
* src/xdgmimemagic.c (_xdg_mime_magic_parse_magic_line): change
|
||||
assertion to avoid a warning.
|
||||
|
||||
Tue Oct 21 15:56:55 2003 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* Makefile: add a simple makefile
|
||||
* src/Makefile: ditto
|
||||
|
||||
Tue Jul 22 15:37:45 2003 Jonathan Blandford <jrb@gnome.org>
|
||||
|
||||
* xdgmime/xdgmime.c (xdg_mime_init): use XDG_DATA_HOME instead of
|
||||
XDG_CONFIG_HOME.
|
||||
|
||||
12
xdgmime-source/Makefile
Normal file
12
xdgmime-source/Makefile
Normal file
@ -0,0 +1,12 @@
|
||||
SUBDIRS=src
|
||||
|
||||
all-recursive clean-recursive:
|
||||
target=`echo $@ | sed s/-recursive//`; \
|
||||
for subdir in $(SUBDIRS); do \
|
||||
(cd $$subdir && make "$$target") \
|
||||
done;
|
||||
|
||||
all: all-recursive
|
||||
|
||||
clean: clean-recursive
|
||||
rm -f *~
|
||||
8
xdgmime-source/README
Normal file
8
xdgmime-source/README
Normal file
@ -0,0 +1,8 @@
|
||||
This module is a simple module that parses the proposed MIME spec listed
|
||||
at http://freedesktop.org/. It is currently targeted at version 0.12.
|
||||
There are no formal releases planned for this module, and it is not
|
||||
intended to be installed at this time. Rather, it is meant to be used
|
||||
by other libraries or applications to add support for the MIME system.
|
||||
|
||||
It is dual-licensed under the terms of the GNU Lesser General Public
|
||||
License, and the Academic Free License, version 2.0.
|
||||
3
xdgmime-source/src/.cvsignore
Normal file
3
xdgmime-source/src/.cvsignore
Normal file
@ -0,0 +1,3 @@
|
||||
test-mime
|
||||
test-mime-data
|
||||
*.o
|
||||
14
xdgmime-source/src/Makefile
Normal file
14
xdgmime-source/src/Makefile
Normal file
@ -0,0 +1,14 @@
|
||||
|
||||
CFLAGS=-Wall -Wmissing-prototypes -Wno-sign-compare -g -DXDG_PREFIX=xdg_test -DHAVE_MMAP
|
||||
|
||||
all: test-mime test-mime-data print-mime-data
|
||||
|
||||
test-mime: xdgmime.o xdgmimeglob.o xdgmimeint.o xdgmimemagic.o xdgmimealias.o xdgmimeparent.o xdgmimecache.o xdgmimeicon.o
|
||||
|
||||
test-mime-data: xdgmime.o xdgmimeglob.o xdgmimeint.o xdgmimemagic.o xdgmimealias.o xdgmimeparent.o xdgmimecache.o xdgmimeicon.o
|
||||
|
||||
print-mime-data: xdgmime.o xdgmimeglob.o xdgmimeint.o xdgmimemagic.o xdgmimealias.o xdgmimeparent.o xdgmimecache.o xdgmimeicon.o
|
||||
|
||||
clean:
|
||||
rm -f *~ *.o test-mime test-mime-data print-mime-data
|
||||
|
||||
187
xdgmime-source/src/print-mime-data.c
Normal file
187
xdgmime-source/src/print-mime-data.c
Normal file
@ -0,0 +1,187 @@
|
||||
/* print-mime-data.c: debug tests for the mime implementation
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2005 Red Hat, Inc.
|
||||
* Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
|
||||
* Copyright (C) 2012 Bastien Nocera <hadess@hadess.net>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <libgen.h>
|
||||
#include <sys/types.h>
|
||||
#include <dirent.h>
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
static void
|
||||
usage (void)
|
||||
{
|
||||
printf ("usage: print-mime-data <DIR>\n\n");
|
||||
printf ("Prints the mime-type of every file in <DIR>, detected in various ways.\n");
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_name (const char *filename)
|
||||
{
|
||||
const char *mt;
|
||||
|
||||
mt = xdg_mime_get_mime_type_from_file_name (filename);
|
||||
|
||||
printf ("\tname: %s\n", mt);
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_data (const char *filename)
|
||||
{
|
||||
FILE *file;
|
||||
const char *mt;
|
||||
int max_extent;
|
||||
char *data;
|
||||
int bytes_read;
|
||||
int result_prio;
|
||||
|
||||
file = fopen (filename, "r");
|
||||
|
||||
if (file == NULL)
|
||||
{
|
||||
printf ("Could not open %s\n", filename);
|
||||
return;
|
||||
}
|
||||
|
||||
max_extent = xdg_mime_get_max_buffer_extents ();
|
||||
data = malloc (max_extent);
|
||||
|
||||
if (data == NULL)
|
||||
{
|
||||
printf ("Failed to allocate memory for file %s\n", filename);
|
||||
fclose (file);
|
||||
return;
|
||||
}
|
||||
|
||||
bytes_read = fread (data, 1, max_extent, file);
|
||||
|
||||
if (ferror (file))
|
||||
{
|
||||
printf ("Error reading file %s\n", filename);
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
mt = xdg_mime_get_mime_type_for_data (data, bytes_read, &result_prio);
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
printf ("\tdata: %s\n", mt);
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_file (const char *filename)
|
||||
{
|
||||
const char *mt;
|
||||
|
||||
mt = xdg_mime_get_mime_type_for_file (filename, NULL);
|
||||
|
||||
printf ("\tfile: %s\n", mt);
|
||||
}
|
||||
|
||||
static int
|
||||
is_regular (const char *filename)
|
||||
{
|
||||
struct stat s;
|
||||
|
||||
if (stat (filename, &s) == 0)
|
||||
if (S_ISREG (s.st_mode))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
process_file (const char *dir, const char *filename)
|
||||
{
|
||||
char path[1024];
|
||||
|
||||
snprintf (path, 1024, "%s/%s", dir, filename);
|
||||
|
||||
if (!is_regular (path))
|
||||
return;
|
||||
|
||||
printf ("%s:\n", filename);
|
||||
|
||||
test_by_name (filename);
|
||||
test_by_data (path);
|
||||
test_by_file (path);
|
||||
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
static void
|
||||
read_from_dir (const char *path)
|
||||
{
|
||||
DIR *dir;
|
||||
struct dirent *entry;
|
||||
|
||||
dir = opendir (path);
|
||||
if (!dir) {
|
||||
printf ("Could not open dir '%s'\n", path);
|
||||
return;
|
||||
}
|
||||
|
||||
entry = readdir (dir);
|
||||
while (entry != NULL) {
|
||||
if (entry->d_name == NULL)
|
||||
goto next;
|
||||
if (strcmp (entry->d_name, ".") == 0 ||
|
||||
strcmp (entry->d_name, "..") == 0)
|
||||
goto next;
|
||||
process_file (path, entry->d_name);
|
||||
|
||||
next:
|
||||
entry = readdir (dir);
|
||||
}
|
||||
|
||||
closedir (dir);
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
|
||||
if (argc < 2)
|
||||
usage ();
|
||||
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
read_from_dir (argv[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
333
xdgmime-source/src/test-mime-data.c
Normal file
333
xdgmime-source/src/test-mime-data.c
Normal file
@ -0,0 +1,333 @@
|
||||
/* test-mime-data.c: tests for the mime implementation
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2005 Red Hat, Inc.
|
||||
* Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <libgen.h>
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
static int error = 0;
|
||||
static int total = 0;
|
||||
static int failed = 0;
|
||||
static int xfailed = 0;
|
||||
static int xmatch = 0;
|
||||
|
||||
static int verbose = 0;
|
||||
|
||||
static void
|
||||
check_mime_type (const char *mt,
|
||||
const char *mt_expected,
|
||||
int xfail,
|
||||
const char *test,
|
||||
const char *filename)
|
||||
{
|
||||
total++;
|
||||
|
||||
if (strcasecmp (mt, mt_expected) != 0)
|
||||
{
|
||||
failed++;
|
||||
|
||||
if (xfail)
|
||||
{
|
||||
xfailed++;
|
||||
|
||||
if (verbose > 1)
|
||||
printf ("%s, '%s' test: expected %s, got %s (expected failure)\n",
|
||||
filename, test, mt_expected, mt);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (verbose > 0)
|
||||
printf ("%s, '%s' test: expected %s, got %s\n",
|
||||
filename, test, mt_expected, mt);
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
if (xfail)
|
||||
{
|
||||
xmatch++;
|
||||
|
||||
if (verbose > 0)
|
||||
printf ("%s, '%s' test: got %s (unexpected match)\n",
|
||||
filename, test, mt);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_name (const char *filename,
|
||||
const char *mt_expected,
|
||||
int xfail)
|
||||
{
|
||||
const char *mt;
|
||||
|
||||
mt = xdg_mime_get_mime_type_from_file_name (filename);
|
||||
|
||||
check_mime_type (mt, mt_expected, xfail, "name", filename);
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_data (const char *dir,
|
||||
const char *filename,
|
||||
const char *mt_expected,
|
||||
int xfail)
|
||||
{
|
||||
FILE *file;
|
||||
const char *mt;
|
||||
int max_extent;
|
||||
char *data;
|
||||
int bytes_read;
|
||||
int result_prio;
|
||||
char path[1024];
|
||||
|
||||
snprintf (path, 1024, "%s/%s", dir, filename);
|
||||
|
||||
file = fopen (path, "r");
|
||||
|
||||
if (file == NULL)
|
||||
{
|
||||
printf ("Could not open %s\n", path);
|
||||
error++;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
max_extent = xdg_mime_get_max_buffer_extents ();
|
||||
data = malloc (max_extent);
|
||||
|
||||
if (data == NULL)
|
||||
{
|
||||
printf ("Failed to allocate memory for file %s\n", filename);
|
||||
error++;
|
||||
|
||||
fclose (file);
|
||||
return;
|
||||
}
|
||||
|
||||
bytes_read = fread (data, 1, max_extent, file);
|
||||
|
||||
if (ferror (file))
|
||||
{
|
||||
printf ("Error reading file %s\n", path);
|
||||
error++;
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
mt = xdg_mime_get_mime_type_for_data (data, bytes_read, &result_prio);
|
||||
|
||||
free (data);
|
||||
fclose (file);
|
||||
|
||||
check_mime_type (mt, mt_expected, xfail, "data", filename);
|
||||
}
|
||||
|
||||
static void
|
||||
test_by_file (const char *dir,
|
||||
const char *filename,
|
||||
const char *mt_expected,
|
||||
int xfail)
|
||||
{
|
||||
const char *mt;
|
||||
char path[1024];
|
||||
|
||||
snprintf (path, 1024, "%s/%s", dir, filename);
|
||||
|
||||
mt = xdg_mime_get_mime_type_for_file (path, NULL);
|
||||
|
||||
check_mime_type (mt, mt_expected, xfail, "file", filename);
|
||||
}
|
||||
|
||||
static void
|
||||
test_single_file (const char *dir,
|
||||
const char *filename,
|
||||
const char *mimetype,
|
||||
int xfail_name,
|
||||
int xfail_data,
|
||||
int xfail_file)
|
||||
{
|
||||
test_by_name (filename, mimetype, xfail_name);
|
||||
test_by_data (dir, filename, mimetype, xfail_data);
|
||||
test_by_file (dir, filename, mimetype, xfail_file);
|
||||
}
|
||||
|
||||
static void
|
||||
read_from_file (const char *filename)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int lineno = 0;
|
||||
char *testfile, *mimetype, *flags;
|
||||
char *rest, *space, end;
|
||||
char *dir, *tmp;
|
||||
int xfail_name, xfail_data, xfail_file;
|
||||
|
||||
file = fopen (filename, "r");
|
||||
tmp = strdup (filename);
|
||||
dir = strdup (dirname (tmp));
|
||||
free (tmp);
|
||||
|
||||
if (file == NULL)
|
||||
{
|
||||
printf ("Could not open %s\n", filename);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
lineno++;
|
||||
|
||||
rest = line;
|
||||
while (*rest == ' ') rest++;
|
||||
|
||||
if (*rest == '#' || *rest == '\n')
|
||||
continue;
|
||||
|
||||
space = strchr (rest, ' ');
|
||||
if (!space)
|
||||
{
|
||||
printf ("Malformed line in %s:%d\n\t%s\n", filename, lineno, line);
|
||||
continue;
|
||||
}
|
||||
|
||||
*space = '\0';
|
||||
testfile = rest;
|
||||
|
||||
rest = space + 1;
|
||||
while (*rest == ' ') rest++;
|
||||
space = rest;
|
||||
while (*space != ' ' && *space != '\n') space++;
|
||||
end = *space;
|
||||
|
||||
*space = '\0';
|
||||
mimetype = rest;
|
||||
|
||||
xfail_name = 0;
|
||||
xfail_data = 0;
|
||||
xfail_file = 0;
|
||||
|
||||
if (end != '\n')
|
||||
{
|
||||
rest = space + 1;
|
||||
while (*rest == ' ') rest++;
|
||||
space = rest;
|
||||
while (*space != ' ' && *space != '\n') space++;
|
||||
end = *space;
|
||||
|
||||
*space = '\0';
|
||||
flags = rest;
|
||||
|
||||
switch (strlen (flags))
|
||||
{
|
||||
default:
|
||||
printf ("%s.%d: Extra flags are ignored\n", filename, lineno);
|
||||
/* Fall thu */
|
||||
case 3:
|
||||
if (flags[2] == 'x')
|
||||
xfail_file = 1;
|
||||
/* Fall thu */
|
||||
case 2:
|
||||
if (flags[1] == 'x')
|
||||
xfail_data = 1;
|
||||
/* Fall thu */
|
||||
case 1:
|
||||
if (flags[0] == 'x')
|
||||
xfail_name = 1;
|
||||
break;
|
||||
case 0: ;
|
||||
/* Should not happen */
|
||||
}
|
||||
}
|
||||
|
||||
test_single_file (dir, testfile, mimetype,
|
||||
xfail_name, xfail_data, xfail_file);
|
||||
}
|
||||
|
||||
fclose (file);
|
||||
|
||||
free (dir);
|
||||
}
|
||||
|
||||
static void
|
||||
usage (void)
|
||||
{
|
||||
printf ("usage: test-mime-data <FILE>\n\n");
|
||||
printf ("Tests the mime system.\n");
|
||||
printf ("Testcases are specified in the following format:\n\n");
|
||||
printf ("# comment\n");
|
||||
printf ("<filename1> <mimetype> [<flags>]\n");
|
||||
printf ("<filename2> <mimetype> [<flags>]\n");
|
||||
printf ("...\n\n");
|
||||
printf ("Where an 'x' in the 1st, 2nd or 3rd position in <flags>\n");
|
||||
printf ("indicates an expected failure when determining the\n");
|
||||
printf ("mimetype by name, data or file.\n");
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
|
||||
if (argc < 2)
|
||||
usage ();
|
||||
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
if (strcmp (argv[i], "-v") == 0)
|
||||
verbose++;
|
||||
else
|
||||
read_from_file (argv[i]);
|
||||
}
|
||||
|
||||
if (error > 0 || failed > 0)
|
||||
{
|
||||
printf ("%d errors, %d comparisons, %d failed",
|
||||
error, total, failed);
|
||||
if (xfailed > 0)
|
||||
printf (" (%d expected)", xfailed);
|
||||
if (xmatch > 0)
|
||||
printf (", %d unexpected successes", xmatch);
|
||||
printf ("\n");
|
||||
|
||||
if (xmatch > 0)
|
||||
return 1;
|
||||
if (xfailed == failed)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
201
xdgmime-source/src/test-mime.c
Normal file
201
xdgmime-source/src/test-mime.c
Normal file
@ -0,0 +1,201 @@
|
||||
/*
|
||||
* Copyright (C) 2003,2004 Red Hat, Inc.
|
||||
* Copyright (C) 2003,2004 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#include "xdgmime.h"
|
||||
#include "xdgmimeglob.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
static void
|
||||
test_individual_glob (const char *glob,
|
||||
XdgGlobType expected_type)
|
||||
{
|
||||
XdgGlobType test_type;
|
||||
|
||||
test_type = _xdg_glob_determine_type (glob);
|
||||
if (test_type != expected_type)
|
||||
{
|
||||
printf ("Test Failed: %s is of type %s, but %s is expected\n",
|
||||
glob,
|
||||
((test_type == XDG_GLOB_LITERAL)?"XDG_GLOB_LITERAL":
|
||||
((test_type == XDG_GLOB_SIMPLE)?"XDG_GLOB_SIMPLE":"XDG_GLOB_FULL")),
|
||||
((expected_type == XDG_GLOB_LITERAL)?"XDG_GLOB_LITERAL":
|
||||
((expected_type == XDG_GLOB_SIMPLE)?"XDG_GLOB_SIMPLE":"XDG_GLOB_COMPLEX")));
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_glob_type (void)
|
||||
{
|
||||
test_individual_glob ("*.gif", XDG_GLOB_SIMPLE);
|
||||
test_individual_glob ("Foo*.gif", XDG_GLOB_FULL);
|
||||
test_individual_glob ("*[4].gif", XDG_GLOB_FULL);
|
||||
test_individual_glob ("Makefile", XDG_GLOB_LITERAL);
|
||||
test_individual_glob ("sldkfjvlsdf\\\\slkdjf", XDG_GLOB_FULL);
|
||||
test_individual_glob ("tree.[ch]", XDG_GLOB_FULL);
|
||||
}
|
||||
|
||||
static void
|
||||
test_alias (const char *mime_a,
|
||||
const char *mime_b,
|
||||
int expected)
|
||||
{
|
||||
int actual;
|
||||
|
||||
actual = xdg_mime_mime_type_equal (mime_a, mime_b);
|
||||
|
||||
if (actual != expected)
|
||||
{
|
||||
printf ("Test Failed: %s is %s to %s\n",
|
||||
mime_a, actual ? "equal" : "not equal", mime_b);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_aliasing (void)
|
||||
{
|
||||
test_alias ("application/wordperfect", "application/vnd.wordperfect", 1);
|
||||
test_alias ("application/x-gnome-app-info", "application/x-desktop", 1);
|
||||
test_alias ("application/x-wordperfect", "application/vnd.wordperfect", 1);
|
||||
test_alias ("application/x-wordperfect", "audio/x-midi", 0);
|
||||
test_alias ("/", "vnd/vnd", 0);
|
||||
test_alias ("application/octet-stream", "text/plain", 0);
|
||||
test_alias ("text/plain", "text/*", 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_subclass (const char *mime_a,
|
||||
const char *mime_b,
|
||||
int expected)
|
||||
{
|
||||
int actual;
|
||||
|
||||
actual = xdg_mime_mime_type_subclass (mime_a, mime_b);
|
||||
|
||||
if (actual != expected)
|
||||
{
|
||||
printf ("Test Failed: %s is %s of %s\n",
|
||||
mime_a, actual ? "subclass" : "not subclass", mime_b);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_subclassing (void)
|
||||
{
|
||||
test_subclass ("application/rtf", "text/plain", 1);
|
||||
test_subclass ("message/news", "text/plain", 1);
|
||||
test_subclass ("message/news", "message/*", 1);
|
||||
test_subclass ("message/news", "text/*", 1);
|
||||
test_subclass ("message/news", "application/octet-stream", 1);
|
||||
test_subclass ("application/rtf", "application/octet-stream", 1);
|
||||
test_subclass ("application/x-gnome-app-info", "text/plain", 1);
|
||||
test_subclass ("image/x-djvu", "image/vnd.djvu", 1);
|
||||
test_subclass ("image/vnd.djvu", "image/x-djvu", 1);
|
||||
test_subclass ("image/vnd.djvu", "text/plain", 0);
|
||||
test_subclass ("image/vnd.djvu", "text/*", 0);
|
||||
test_subclass ("text/*", "text/plain", 1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_one_match (const char *filename, const char *expected)
|
||||
{
|
||||
const char *actual;
|
||||
|
||||
actual = xdg_mime_get_mime_type_from_file_name (filename);
|
||||
|
||||
if (strcasecmp (actual, expected) != 0)
|
||||
{
|
||||
printf ("Test Failed: mime type of %s is %s, expected %s\n",
|
||||
filename, actual, expected);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_matches (void)
|
||||
{
|
||||
test_one_match ("foo.bar.epub", "application/epub+zip");
|
||||
test_one_match ("core", "application/x-core");
|
||||
test_one_match ("README.in", "text/x-readme");
|
||||
test_one_match ("README.gz", "application/gzip");
|
||||
test_one_match ("blabla.cs", "text/x-csharp");
|
||||
test_one_match ("blabla.f90", "text/x-fortran");
|
||||
test_one_match ("blabla.F95", "text/x-fortran");
|
||||
test_one_match ("tarball.tar.gz", "application/x-compressed-tar");
|
||||
test_one_match ("file.gz", "application/gzip");
|
||||
test_one_match ("file.tar.lzo", "application/x-tzo");
|
||||
test_one_match ("file.lzo", "application/x-lzop");
|
||||
}
|
||||
|
||||
static void
|
||||
test_one_icon (const char *mimetype, const char *expected)
|
||||
{
|
||||
const char *actual;
|
||||
|
||||
actual = xdg_mime_get_generic_icon (mimetype);
|
||||
|
||||
if (actual != expected && (actual == NULL || strcmp (actual, expected) != 0))
|
||||
{
|
||||
printf ("Test Failed: icon of %s is %s, expected %s\n",
|
||||
mimetype, actual, expected);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_icons (void)
|
||||
{
|
||||
test_one_icon ("application/x-font-ttx", "font-x-generic");
|
||||
test_one_icon ("application/mathematica", "x-office-document");
|
||||
test_one_icon ("text/plain", NULL);
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
const char *result;
|
||||
const char *file_name;
|
||||
int i;
|
||||
|
||||
test_glob_type ();
|
||||
test_aliasing ();
|
||||
test_subclassing ();
|
||||
test_matches ();
|
||||
test_icons ();
|
||||
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
file_name = argv[i];
|
||||
result = xdg_mime_get_mime_type_for_file (file_name, NULL);
|
||||
printf ("File \"%s\" has a mime-type of %s\n", file_name, result);
|
||||
}
|
||||
|
||||
#if 0
|
||||
xdg_mime_dump ();
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
945
xdgmime-source/src/xdgmime.c
Normal file
945
xdgmime-source/src/xdgmime.c
Normal file
@ -0,0 +1,945 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmime.c: XDG Mime Spec mime resolver. Based on version 0.11 of the spec.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003,2004 Red Hat, Inc.
|
||||
* Copyright (C) 2003,2004 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmime.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include "xdgmimeglob.h"
|
||||
#include "xdgmimemagic.h"
|
||||
#include "xdgmimealias.h"
|
||||
#include "xdgmimeicon.h"
|
||||
#include "xdgmimeparent.h"
|
||||
#include "xdgmimecache.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
|
||||
typedef struct XdgDirTimeList XdgDirTimeList;
|
||||
typedef struct XdgCallbackList XdgCallbackList;
|
||||
|
||||
static int need_reread = TRUE;
|
||||
static time_t last_stat_time = 0;
|
||||
|
||||
static XdgGlobHash *global_hash = NULL;
|
||||
static XdgMimeMagic *global_magic = NULL;
|
||||
static XdgAliasList *alias_list = NULL;
|
||||
static XdgParentList *parent_list = NULL;
|
||||
static XdgDirTimeList *dir_time_list = NULL;
|
||||
static XdgCallbackList *callback_list = NULL;
|
||||
static XdgIconList *icon_list = NULL;
|
||||
static XdgIconList *generic_icon_list = NULL;
|
||||
|
||||
XdgMimeCache **_caches = NULL;
|
||||
static int n_caches = 0;
|
||||
|
||||
const char xdg_mime_type_unknown[] = "application/octet-stream";
|
||||
const char xdg_mime_type_empty[] = "application/x-zerosize";
|
||||
const char xdg_mime_type_textplain[] = "text/plain";
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
XDG_CHECKED_UNCHECKED,
|
||||
XDG_CHECKED_VALID,
|
||||
XDG_CHECKED_INVALID
|
||||
};
|
||||
|
||||
struct XdgDirTimeList
|
||||
{
|
||||
time_t mtime;
|
||||
char *directory_name;
|
||||
int checked;
|
||||
XdgDirTimeList *next;
|
||||
};
|
||||
|
||||
struct XdgCallbackList
|
||||
{
|
||||
XdgCallbackList *next;
|
||||
XdgCallbackList *prev;
|
||||
int callback_id;
|
||||
XdgMimeCallback callback;
|
||||
void *data;
|
||||
XdgMimeDestroy destroy;
|
||||
};
|
||||
|
||||
/* Function called by xdg_run_command_on_dirs. If it returns TRUE, further
|
||||
* directories aren't looked at */
|
||||
typedef int (*XdgDirectoryFunc) (const char *directory,
|
||||
void *user_data);
|
||||
|
||||
static void
|
||||
xdg_dir_time_list_add (char *file_name,
|
||||
time_t mtime)
|
||||
{
|
||||
XdgDirTimeList *list;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
{
|
||||
if (strcmp (list->directory_name, file_name) == 0)
|
||||
{
|
||||
free (file_name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
list = calloc (1, sizeof (XdgDirTimeList));
|
||||
list->checked = XDG_CHECKED_UNCHECKED;
|
||||
list->directory_name = file_name;
|
||||
list->mtime = mtime;
|
||||
list->next = dir_time_list;
|
||||
dir_time_list = list;
|
||||
}
|
||||
|
||||
static void
|
||||
xdg_dir_time_list_free (XdgDirTimeList *list)
|
||||
{
|
||||
XdgDirTimeList *next;
|
||||
|
||||
while (list)
|
||||
{
|
||||
next = list->next;
|
||||
free (list->directory_name);
|
||||
free (list);
|
||||
list = next;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
xdg_mime_init_from_directory (const char *directory,
|
||||
void *user_data)
|
||||
{
|
||||
char *file_name;
|
||||
struct stat st;
|
||||
|
||||
assert (directory != NULL);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
XdgMimeCache *cache = _xdg_mime_cache_new_from_file (file_name);
|
||||
|
||||
if (cache != NULL)
|
||||
{
|
||||
xdg_dir_time_list_add (file_name, st.st_mtime);
|
||||
|
||||
_caches = realloc (_caches, sizeof (XdgMimeCache *) * (n_caches + 2));
|
||||
_caches[n_caches] = cache;
|
||||
_caches[n_caches + 1] = NULL;
|
||||
n_caches++;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/globs2") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/globs2");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
_xdg_mime_glob_read_from_file (global_hash, file_name, TRUE);
|
||||
xdg_dir_time_list_add (file_name, st.st_mtime);
|
||||
}
|
||||
else
|
||||
{
|
||||
free (file_name);
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/globs");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
_xdg_mime_glob_read_from_file (global_hash, file_name, FALSE);
|
||||
xdg_dir_time_list_add (file_name, st.st_mtime);
|
||||
}
|
||||
else
|
||||
{
|
||||
free (file_name);
|
||||
}
|
||||
}
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/magic");
|
||||
if (stat (file_name, &st) == 0)
|
||||
{
|
||||
_xdg_mime_magic_read_from_file (global_magic, file_name);
|
||||
xdg_dir_time_list_add (file_name, st.st_mtime);
|
||||
}
|
||||
else
|
||||
{
|
||||
free (file_name);
|
||||
}
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/aliases") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/aliases");
|
||||
_xdg_mime_alias_read_from_file (alias_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/subclasses") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/subclasses");
|
||||
_xdg_mime_parent_read_from_file (parent_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/icons") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/icons");
|
||||
_xdg_mime_icon_read_from_file (icon_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/generic-icons") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/generic-icons");
|
||||
_xdg_mime_icon_read_from_file (generic_icon_list, file_name);
|
||||
free (file_name);
|
||||
|
||||
return FALSE; /* Keep processing */
|
||||
}
|
||||
|
||||
/* Runs a command on all the directories in the search path */
|
||||
static void
|
||||
xdg_run_command_on_dirs (XdgDirectoryFunc func,
|
||||
void *user_data)
|
||||
{
|
||||
const char *xdg_data_home;
|
||||
const char *xdg_data_dirs;
|
||||
const char *ptr;
|
||||
|
||||
xdg_data_home = getenv ("XDG_DATA_HOME");
|
||||
if (xdg_data_home)
|
||||
{
|
||||
if ((func) (xdg_data_home, user_data))
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
const char *home;
|
||||
|
||||
home = getenv ("HOME");
|
||||
if (home != NULL)
|
||||
{
|
||||
char *guessed_xdg_home;
|
||||
int stop_processing;
|
||||
|
||||
guessed_xdg_home = malloc (strlen (home) + strlen ("/.local/share/") + 1);
|
||||
strcpy (guessed_xdg_home, home);
|
||||
strcat (guessed_xdg_home, "/.local/share/");
|
||||
stop_processing = (func) (guessed_xdg_home, user_data);
|
||||
free (guessed_xdg_home);
|
||||
|
||||
if (stop_processing)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
xdg_data_dirs = getenv ("XDG_DATA_DIRS");
|
||||
if (xdg_data_dirs == NULL)
|
||||
xdg_data_dirs = "/usr/local/share/:/usr/share/";
|
||||
|
||||
ptr = xdg_data_dirs;
|
||||
|
||||
while (*ptr != '\000')
|
||||
{
|
||||
const char *end_ptr;
|
||||
char *dir;
|
||||
int len;
|
||||
int stop_processing;
|
||||
|
||||
end_ptr = ptr;
|
||||
while (*end_ptr != ':' && *end_ptr != '\000')
|
||||
end_ptr ++;
|
||||
|
||||
if (end_ptr == ptr)
|
||||
{
|
||||
ptr++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (*end_ptr == ':')
|
||||
len = end_ptr - ptr;
|
||||
else
|
||||
len = end_ptr - ptr + 1;
|
||||
dir = malloc (len + 1);
|
||||
strncpy (dir, ptr, len);
|
||||
dir[len] = '\0';
|
||||
stop_processing = (func) (dir, user_data);
|
||||
free (dir);
|
||||
|
||||
if (stop_processing)
|
||||
return;
|
||||
|
||||
ptr = end_ptr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Checks file_path to make sure it has the same mtime as last time it was
|
||||
* checked. If it has a different mtime, or if the file doesn't exist, it
|
||||
* returns FALSE.
|
||||
*
|
||||
* FIXME: This doesn't protect against permission changes.
|
||||
*/
|
||||
static int
|
||||
xdg_check_file (const char *file_path,
|
||||
int *exists)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
/* If the file exists */
|
||||
if (stat (file_path, &st) == 0)
|
||||
{
|
||||
XdgDirTimeList *list;
|
||||
|
||||
if (exists)
|
||||
*exists = TRUE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
{
|
||||
if (! strcmp (list->directory_name, file_path))
|
||||
{
|
||||
if (st.st_mtime == list->mtime)
|
||||
list->checked = XDG_CHECKED_VALID;
|
||||
else
|
||||
list->checked = XDG_CHECKED_INVALID;
|
||||
|
||||
return (list->checked != XDG_CHECKED_VALID);
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if (exists)
|
||||
*exists = FALSE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
xdg_check_dir (const char *directory,
|
||||
void *user_data)
|
||||
{
|
||||
int invalid, exists;
|
||||
char *file_name;
|
||||
int* invalid_dir_list = user_data;
|
||||
|
||||
assert (directory != NULL);
|
||||
|
||||
/* Check the mime.cache file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
|
||||
invalid = xdg_check_file (file_name, &exists);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
else if (exists)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Check the globs file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/globs");
|
||||
invalid = xdg_check_file (file_name, NULL);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Check the magic file */
|
||||
file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
|
||||
strcpy (file_name, directory); strcat (file_name, "/mime/magic");
|
||||
invalid = xdg_check_file (file_name, NULL);
|
||||
free (file_name);
|
||||
if (invalid)
|
||||
{
|
||||
*invalid_dir_list = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE; /* Keep processing */
|
||||
}
|
||||
|
||||
/* Walks through all the mime files stat()ing them to see if they've changed.
|
||||
* Returns TRUE if they have. */
|
||||
static int
|
||||
xdg_check_dirs (void)
|
||||
{
|
||||
XdgDirTimeList *list;
|
||||
int invalid_dir_list = FALSE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
list->checked = XDG_CHECKED_UNCHECKED;
|
||||
|
||||
xdg_run_command_on_dirs (xdg_check_dir, &invalid_dir_list);
|
||||
|
||||
if (invalid_dir_list)
|
||||
return TRUE;
|
||||
|
||||
for (list = dir_time_list; list; list = list->next)
|
||||
{
|
||||
if (list->checked != XDG_CHECKED_VALID)
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* We want to avoid stat()ing on every single mime call, so we only look for
|
||||
* newer files every 5 seconds. This will return TRUE if we need to reread the
|
||||
* mime data from disk.
|
||||
*/
|
||||
static int
|
||||
xdg_check_time_and_dirs (void)
|
||||
{
|
||||
struct timeval tv;
|
||||
time_t current_time;
|
||||
int retval = FALSE;
|
||||
|
||||
gettimeofday (&tv, NULL);
|
||||
current_time = tv.tv_sec;
|
||||
|
||||
if (current_time >= last_stat_time + 5)
|
||||
{
|
||||
retval = xdg_check_dirs ();
|
||||
last_stat_time = current_time;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Called in every public function. It reloads the hash function if need be.
|
||||
*/
|
||||
static void
|
||||
xdg_mime_init (void)
|
||||
{
|
||||
if (xdg_check_time_and_dirs ())
|
||||
{
|
||||
xdg_mime_shutdown ();
|
||||
}
|
||||
|
||||
if (need_reread)
|
||||
{
|
||||
global_hash = _xdg_glob_hash_new ();
|
||||
global_magic = _xdg_mime_magic_new ();
|
||||
alias_list = _xdg_mime_alias_list_new ();
|
||||
parent_list = _xdg_mime_parent_list_new ();
|
||||
icon_list = _xdg_mime_icon_list_new ();
|
||||
generic_icon_list = _xdg_mime_icon_list_new ();
|
||||
|
||||
xdg_run_command_on_dirs (xdg_mime_init_from_directory, NULL);
|
||||
|
||||
need_reread = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_for_data (const void *data,
|
||||
size_t len,
|
||||
int *result_prio)
|
||||
{
|
||||
const char *mime_type;
|
||||
|
||||
if (len == 0)
|
||||
{
|
||||
if (result_prio != NULL)
|
||||
*result_prio = 100;
|
||||
return XDG_MIME_TYPE_EMPTY;
|
||||
}
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
mime_type = _xdg_mime_cache_get_mime_type_for_data (data, len, result_prio);
|
||||
else
|
||||
mime_type = _xdg_mime_magic_lookup_data (global_magic, data, len, result_prio, NULL, 0);
|
||||
|
||||
if (mime_type)
|
||||
return mime_type;
|
||||
|
||||
return _xdg_binary_or_text_fallback(data, len);
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf)
|
||||
{
|
||||
const char *mime_type;
|
||||
/* currently, only a few globs occur twice, and none
|
||||
* more often, so 5 seems plenty.
|
||||
*/
|
||||
const char *mime_types[5];
|
||||
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;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_type_for_file (file_name, statbuf);
|
||||
|
||||
base_name = _xdg_get_base_name (file_name);
|
||||
n = _xdg_glob_hash_lookup_file_name (global_hash, base_name, mime_types, 5);
|
||||
|
||||
if (n == 1)
|
||||
return mime_types[0];
|
||||
|
||||
if (!statbuf)
|
||||
{
|
||||
if (stat (file_name, &buf) != 0)
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
|
||||
statbuf = &buf;
|
||||
}
|
||||
|
||||
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_magic_get_buffer_extents (global_magic);
|
||||
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 = _xdg_mime_magic_lookup_data (global_magic, 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;
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_mime_type_from_file_name (const char *file_name)
|
||||
{
|
||||
const char *mime_type;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_type_from_file_name (file_name);
|
||||
|
||||
if (_xdg_glob_hash_lookup_file_name (global_hash, file_name, &mime_type, 1))
|
||||
return mime_type;
|
||||
else
|
||||
return XDG_MIME_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_get_mime_types_from_file_name (const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_mime_types_from_file_name (file_name, mime_types, n_mime_types);
|
||||
|
||||
return _xdg_glob_hash_lookup_file_name (global_hash, file_name, mime_types, n_mime_types);
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_is_valid_mime_type (const char *mime_type)
|
||||
{
|
||||
/* FIXME: We should make this a better test
|
||||
*/
|
||||
return _xdg_utf8_validate (mime_type);
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_shutdown (void)
|
||||
{
|
||||
XdgCallbackList *list;
|
||||
|
||||
/* FIXME: Need to make this (and the whole library) thread safe */
|
||||
if (dir_time_list)
|
||||
{
|
||||
xdg_dir_time_list_free (dir_time_list);
|
||||
dir_time_list = NULL;
|
||||
}
|
||||
|
||||
if (global_hash)
|
||||
{
|
||||
_xdg_glob_hash_free (global_hash);
|
||||
global_hash = NULL;
|
||||
}
|
||||
if (global_magic)
|
||||
{
|
||||
_xdg_mime_magic_free (global_magic);
|
||||
global_magic = NULL;
|
||||
}
|
||||
|
||||
if (alias_list)
|
||||
{
|
||||
_xdg_mime_alias_list_free (alias_list);
|
||||
alias_list = NULL;
|
||||
}
|
||||
|
||||
if (parent_list)
|
||||
{
|
||||
_xdg_mime_parent_list_free (parent_list);
|
||||
parent_list = NULL;
|
||||
}
|
||||
|
||||
if (icon_list)
|
||||
{
|
||||
_xdg_mime_icon_list_free (icon_list);
|
||||
icon_list = NULL;
|
||||
}
|
||||
|
||||
if (generic_icon_list)
|
||||
{
|
||||
_xdg_mime_icon_list_free (generic_icon_list);
|
||||
generic_icon_list = NULL;
|
||||
}
|
||||
|
||||
if (_caches)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_caches; i++)
|
||||
_xdg_mime_cache_unref (_caches[i]);
|
||||
free (_caches);
|
||||
_caches = NULL;
|
||||
n_caches = 0;
|
||||
}
|
||||
|
||||
for (list = callback_list; list; list = list->next)
|
||||
(list->callback) (list->data);
|
||||
|
||||
need_reread = TRUE;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_get_max_buffer_extents (void)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_max_buffer_extents ();
|
||||
|
||||
return _xdg_mime_magic_get_buffer_extents (global_magic);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_unalias_mime_type (const char *mime_type)
|
||||
{
|
||||
const char *lookup;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_unalias_mime_type (mime_type);
|
||||
|
||||
if ((lookup = _xdg_mime_alias_list_lookup (alias_list, mime_type)) != NULL)
|
||||
return lookup;
|
||||
|
||||
return mime_type;
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_unalias_mime_type (const char *mime_type)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_unalias_mime_type (mime_type);
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
const char *unalias_a, *unalias_b;
|
||||
|
||||
unalias_a = _xdg_mime_unalias_mime_type (mime_a);
|
||||
unalias_b = _xdg_mime_unalias_mime_type (mime_b);
|
||||
|
||||
if (strcmp (unalias_a, unalias_b) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_mime_type_equal (mime_a, mime_b);
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_media_type_equal (const char *mime_a,
|
||||
const char *mime_b)
|
||||
{
|
||||
char *sep;
|
||||
|
||||
sep = strchr (mime_a, '/');
|
||||
|
||||
if (sep && strncmp (mime_a, mime_b, sep - mime_a + 1) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 1
|
||||
static int
|
||||
ends_with (const char *str,
|
||||
const char *suffix)
|
||||
{
|
||||
int length;
|
||||
int suffix_length;
|
||||
|
||||
length = strlen (str);
|
||||
suffix_length = strlen (suffix);
|
||||
if (length < suffix_length)
|
||||
return 0;
|
||||
|
||||
if (strcmp (str + length - suffix_length, suffix) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
xdg_mime_is_super_type (const char *mime)
|
||||
{
|
||||
return ends_with (mime, "/*");
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
_xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base)
|
||||
{
|
||||
const char *umime, *ubase;
|
||||
const char **parents;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_mime_type_subclass (mime, base);
|
||||
|
||||
umime = _xdg_mime_unalias_mime_type (mime);
|
||||
ubase = _xdg_mime_unalias_mime_type (base);
|
||||
|
||||
if (strcmp (umime, ubase) == 0)
|
||||
return 1;
|
||||
|
||||
#if 1
|
||||
/* Handle supertypes */
|
||||
if (xdg_mime_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;
|
||||
|
||||
parents = _xdg_mime_parent_list_lookup (parent_list, umime);
|
||||
for (; parents && *parents; parents++)
|
||||
{
|
||||
if (_xdg_mime_mime_type_subclass (*parents, ubase))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
return _xdg_mime_mime_type_subclass (mime, base);
|
||||
}
|
||||
|
||||
char **
|
||||
xdg_mime_list_mime_parents (const char *mime)
|
||||
{
|
||||
const char **parents;
|
||||
char **result;
|
||||
int i, n;
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_list_mime_parents (mime);
|
||||
|
||||
parents = xdg_mime_get_mime_parents (mime);
|
||||
|
||||
if (!parents)
|
||||
return NULL;
|
||||
|
||||
for (i = 0; parents[i]; i++) ;
|
||||
|
||||
n = (i + 1) * sizeof (char *);
|
||||
result = (char **) malloc (n);
|
||||
memcpy (result, parents, n);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const char **
|
||||
xdg_mime_get_mime_parents (const char *mime)
|
||||
{
|
||||
const char *umime;
|
||||
|
||||
xdg_mime_init ();
|
||||
|
||||
umime = _xdg_mime_unalias_mime_type (mime);
|
||||
|
||||
return _xdg_mime_parent_list_lookup (parent_list, umime);
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_dump (void)
|
||||
{
|
||||
xdg_mime_init();
|
||||
|
||||
printf ("*** ALIASES ***\n\n");
|
||||
_xdg_mime_alias_list_dump (alias_list);
|
||||
printf ("\n*** PARENTS ***\n\n");
|
||||
_xdg_mime_parent_list_dump (parent_list);
|
||||
printf ("\n*** CACHE ***\n\n");
|
||||
_xdg_glob_hash_dump (global_hash);
|
||||
printf ("\n*** GLOBS ***\n\n");
|
||||
_xdg_glob_hash_dump (global_hash);
|
||||
printf ("\n*** GLOBS REVERSE TREE ***\n\n");
|
||||
_xdg_mime_cache_glob_dump ();
|
||||
}
|
||||
|
||||
|
||||
/* Registers a function to be called every time the mime database reloads its files
|
||||
*/
|
||||
int
|
||||
xdg_mime_register_reload_callback (XdgMimeCallback callback,
|
||||
void *data,
|
||||
XdgMimeDestroy destroy)
|
||||
{
|
||||
XdgCallbackList *list_el;
|
||||
static int callback_id = 1;
|
||||
|
||||
/* Make a new list element */
|
||||
list_el = calloc (1, sizeof (XdgCallbackList));
|
||||
list_el->callback_id = callback_id;
|
||||
list_el->callback = callback;
|
||||
list_el->data = data;
|
||||
list_el->destroy = destroy;
|
||||
list_el->next = callback_list;
|
||||
if (list_el->next)
|
||||
list_el->next->prev = list_el;
|
||||
|
||||
callback_list = list_el;
|
||||
callback_id ++;
|
||||
|
||||
return callback_id - 1;
|
||||
}
|
||||
|
||||
void
|
||||
xdg_mime_remove_callback (int callback_id)
|
||||
{
|
||||
XdgCallbackList *list;
|
||||
|
||||
for (list = callback_list; list; list = list->next)
|
||||
{
|
||||
if (list->callback_id == callback_id)
|
||||
{
|
||||
if (list->next)
|
||||
list->next = list->prev;
|
||||
|
||||
if (list->prev)
|
||||
list->prev->next = list->next;
|
||||
else
|
||||
callback_list = list->next;
|
||||
|
||||
/* invoke the destroy handler */
|
||||
(list->destroy) (list->data);
|
||||
free (list);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_icon (const char *mime)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_icon (mime);
|
||||
|
||||
return _xdg_mime_icon_list_lookup (icon_list, mime);
|
||||
}
|
||||
|
||||
const char *
|
||||
xdg_mime_get_generic_icon (const char *mime)
|
||||
{
|
||||
xdg_mime_init ();
|
||||
|
||||
if (_caches)
|
||||
return _xdg_mime_cache_get_generic_icon (mime);
|
||||
|
||||
return _xdg_mime_icon_list_lookup (generic_icon_list, mime);
|
||||
}
|
||||
133
xdgmime-source/src/xdgmime.h
Normal file
133
xdgmime-source/src/xdgmime.h
Normal file
@ -0,0 +1,133 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmime.h: XDG Mime Spec mime resolver. Based on version 0.11 of the spec.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __XDG_MIME_H__
|
||||
#define __XDG_MIME_H__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define XDG_ENTRY(func) _XDG_ENTRY2(XDG_PREFIX,func)
|
||||
#define _XDG_ENTRY2(prefix,func) _XDG_ENTRY3(prefix,func)
|
||||
#define _XDG_ENTRY3(prefix,func) prefix##_##func
|
||||
|
||||
#define XDG_RESERVED_ENTRY(func) _XDG_RESERVED_ENTRY2(XDG_PREFIX,func)
|
||||
#define _XDG_RESERVED_ENTRY2(prefix,func) _XDG_RESERVED_ENTRY3(prefix,func)
|
||||
#define _XDG_RESERVED_ENTRY3(prefix,func) _##prefix##_##func
|
||||
#endif
|
||||
|
||||
typedef void (*XdgMimeCallback) (void *user_data);
|
||||
typedef void (*XdgMimeDestroy) (void *user_data);
|
||||
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define xdg_mime_get_mime_type_for_data XDG_ENTRY(get_mime_type_for_data)
|
||||
#define xdg_mime_get_mime_type_for_file XDG_ENTRY(get_mime_type_for_file)
|
||||
#define xdg_mime_get_mime_type_from_file_name XDG_ENTRY(get_mime_type_from_file_name)
|
||||
#define xdg_mime_get_mime_types_from_file_name XDG_ENTRY(get_mime_types_from_file_name)
|
||||
#define xdg_mime_is_valid_mime_type XDG_ENTRY(is_valid_mime_type)
|
||||
#define xdg_mime_mime_type_equal XDG_ENTRY(mime_type_equal)
|
||||
#define xdg_mime_media_type_equal XDG_ENTRY(media_type_equal)
|
||||
#define xdg_mime_mime_type_subclass XDG_ENTRY(mime_type_subclass)
|
||||
#define xdg_mime_get_mime_parents XDG_ENTRY(get_mime_parents)
|
||||
#define xdg_mime_list_mime_parents XDG_ENTRY(list_mime_parents)
|
||||
#define xdg_mime_unalias_mime_type XDG_ENTRY(unalias_mime_type)
|
||||
#define xdg_mime_get_max_buffer_extents XDG_ENTRY(get_max_buffer_extents)
|
||||
#define xdg_mime_shutdown XDG_ENTRY(shutdown)
|
||||
#define xdg_mime_dump XDG_ENTRY(dump)
|
||||
#define xdg_mime_register_reload_callback XDG_ENTRY(register_reload_callback)
|
||||
#define xdg_mime_remove_callback XDG_ENTRY(remove_callback)
|
||||
#define xdg_mime_type_unknown XDG_ENTRY(type_unknown)
|
||||
#define xdg_mime_type_empty XDG_ENTRY(type_empty)
|
||||
#define xdg_mime_type_textplain XDG_ENTRY(type_textplain)
|
||||
#define xdg_mime_get_icon XDG_ENTRY(get_icon)
|
||||
#define xdg_mime_get_generic_icon XDG_ENTRY(get_generic_icon)
|
||||
|
||||
#define _xdg_mime_mime_type_equal XDG_RESERVED_ENTRY(mime_type_equal)
|
||||
#define _xdg_mime_mime_type_subclass XDG_RESERVED_ENTRY(mime_type_subclass)
|
||||
#define _xdg_mime_unalias_mime_type XDG_RESERVED_ENTRY(unalias_mime_type)
|
||||
#endif
|
||||
|
||||
extern const char xdg_mime_type_unknown[];
|
||||
extern const char xdg_mime_type_empty[];
|
||||
extern const char xdg_mime_type_textplain[];
|
||||
#define XDG_MIME_TYPE_UNKNOWN xdg_mime_type_unknown
|
||||
#define XDG_MIME_TYPE_EMPTY xdg_mime_type_empty
|
||||
#define XDG_MIME_TYPE_TEXTPLAIN xdg_mime_type_textplain
|
||||
|
||||
const char *xdg_mime_get_mime_type_for_data (const void *data,
|
||||
size_t len,
|
||||
int *result_prio);
|
||||
const char *xdg_mime_get_mime_type_for_file (const char *file_name,
|
||||
struct stat *statbuf);
|
||||
const char *xdg_mime_get_mime_type_from_file_name (const char *file_name);
|
||||
int xdg_mime_get_mime_types_from_file_name(const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
int xdg_mime_is_valid_mime_type (const char *mime_type);
|
||||
int xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int xdg_mime_media_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int xdg_mime_mime_type_subclass (const char *mime_a,
|
||||
const char *mime_b);
|
||||
/* xdg_mime_get_mime_parents() is deprecated since it does
|
||||
* not work correctly with caches. Use xdg_mime_list_parents()
|
||||
* instead, but notice that that function expects you to free
|
||||
* the array it returns.
|
||||
*/
|
||||
const char **xdg_mime_get_mime_parents (const char *mime);
|
||||
char ** xdg_mime_list_mime_parents (const char *mime);
|
||||
const char *xdg_mime_unalias_mime_type (const char *mime);
|
||||
const char *xdg_mime_get_icon (const char *mime);
|
||||
const char *xdg_mime_get_generic_icon (const char *mime);
|
||||
int xdg_mime_get_max_buffer_extents (void);
|
||||
void xdg_mime_shutdown (void);
|
||||
void xdg_mime_dump (void);
|
||||
int xdg_mime_register_reload_callback (XdgMimeCallback callback,
|
||||
void *data,
|
||||
XdgMimeDestroy destroy);
|
||||
void xdg_mime_remove_callback (int callback_id);
|
||||
|
||||
/* Private versions of functions that don't call xdg_mime_init () */
|
||||
int _xdg_mime_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_mime_type_subclass (const char *mime,
|
||||
const char *base);
|
||||
const char *_xdg_mime_unalias_mime_type (const char *mime);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __XDG_MIME_H__ */
|
||||
184
xdgmime-source/src/xdgmimealias.c
Normal file
184
xdgmime-source/src/xdgmimealias.c
Normal file
@ -0,0 +1,184 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.c: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 2004 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimealias.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgAlias XdgAlias;
|
||||
|
||||
struct XdgAlias
|
||||
{
|
||||
char *alias;
|
||||
char *mime_type;
|
||||
};
|
||||
|
||||
struct XdgAliasList
|
||||
{
|
||||
struct XdgAlias *aliases;
|
||||
int n_aliases;
|
||||
};
|
||||
|
||||
XdgAliasList *
|
||||
_xdg_mime_alias_list_new (void)
|
||||
{
|
||||
XdgAliasList *list;
|
||||
|
||||
list = malloc (sizeof (XdgAliasList));
|
||||
|
||||
list->aliases = NULL;
|
||||
list->n_aliases = 0;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_alias_list_free (XdgAliasList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->aliases)
|
||||
{
|
||||
for (i = 0; i < list->n_aliases; i++)
|
||||
{
|
||||
free (list->aliases[i].alias);
|
||||
free (list->aliases[i].mime_type);
|
||||
}
|
||||
free (list->aliases);
|
||||
}
|
||||
free (list);
|
||||
}
|
||||
|
||||
static int
|
||||
alias_entry_cmp (const void *v1, const void *v2)
|
||||
{
|
||||
return strcmp (((XdgAlias *)v1)->alias, ((XdgAlias *)v2)->alias);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_alias_list_lookup (XdgAliasList *list,
|
||||
const char *alias)
|
||||
{
|
||||
XdgAlias *entry;
|
||||
XdgAlias key;
|
||||
|
||||
if (list->n_aliases > 0)
|
||||
{
|
||||
key.alias = (char *)alias;
|
||||
key.mime_type = NULL;
|
||||
|
||||
entry = bsearch (&key, list->aliases, list->n_aliases,
|
||||
sizeof (XdgAlias), alias_entry_cmp);
|
||||
if (entry)
|
||||
return entry->mime_type;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_alias_read_from_file (XdgAliasList *list,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int alloc;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
|
||||
if (file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
alloc = list->n_aliases + 16;
|
||||
list->aliases = realloc (list->aliases, alloc * sizeof (XdgAlias));
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
char *sep;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
sep = strchr (line, ' ');
|
||||
if (sep == NULL)
|
||||
continue;
|
||||
*(sep++) = '\000';
|
||||
sep[strlen (sep) -1] = '\000';
|
||||
if (list->n_aliases == alloc)
|
||||
{
|
||||
alloc <<= 1;
|
||||
list->aliases = realloc (list->aliases,
|
||||
alloc * sizeof (XdgAlias));
|
||||
}
|
||||
list->aliases[list->n_aliases].alias = strdup (line);
|
||||
list->aliases[list->n_aliases].mime_type = strdup (sep);
|
||||
list->n_aliases++;
|
||||
}
|
||||
list->aliases = realloc (list->aliases,
|
||||
list->n_aliases * sizeof (XdgAlias));
|
||||
|
||||
fclose (file);
|
||||
|
||||
if (list->n_aliases > 1)
|
||||
qsort (list->aliases, list->n_aliases,
|
||||
sizeof (XdgAlias), alias_entry_cmp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_alias_list_dump (XdgAliasList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->aliases)
|
||||
{
|
||||
for (i = 0; i < list->n_aliases; i++)
|
||||
{
|
||||
printf ("%s %s\n",
|
||||
list->aliases[i].alias,
|
||||
list->aliases[i].mime_type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
51
xdgmime-source/src/xdgmimealias.h
Normal file
51
xdgmime-source/src/xdgmimealias.h
Normal file
@ -0,0 +1,51 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.h: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 200 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_ALIAS_H__
|
||||
#define __XDG_MIME_ALIAS_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgAliasList XdgAliasList;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_alias_read_from_file XDG_RESERVED_ENTRY(alias_read_from_file)
|
||||
#define _xdg_mime_alias_list_new XDG_RESERVED_ENTRY(alias_list_new)
|
||||
#define _xdg_mime_alias_list_free XDG_RESERVED_ENTRY(alias_list_free)
|
||||
#define _xdg_mime_alias_list_lookup XDG_RESERVED_ENTRY(alias_list_lookup)
|
||||
#define _xdg_mime_alias_list_dump XDG_RESERVED_ENTRY(alias_list_dump)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_alias_read_from_file (XdgAliasList *list,
|
||||
const char *file_name);
|
||||
XdgAliasList *_xdg_mime_alias_list_new (void);
|
||||
void _xdg_mime_alias_list_free (XdgAliasList *list);
|
||||
const char *_xdg_mime_alias_list_lookup (XdgAliasList *list,
|
||||
const char *alias);
|
||||
void _xdg_mime_alias_list_dump (XdgAliasList *list);
|
||||
|
||||
#endif /* __XDG_MIME_ALIAS_H__ */
|
||||
1071
xdgmime-source/src/xdgmimecache.c
Normal file
1071
xdgmime-source/src/xdgmimecache.c
Normal file
File diff suppressed because it is too large
Load Diff
81
xdgmime-source/src/xdgmimecache.h
Normal file
81
xdgmime-source/src/xdgmimecache.h
Normal file
@ -0,0 +1,81 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimecache.h: Private file. Datastructure for mmapped caches.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2005 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_CACHE_H__
|
||||
#define __XDG_MIME_CACHE_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct _XdgMimeCache XdgMimeCache;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_cache_new_from_file XDG_RESERVED_ENTRY(cache_new_from_file)
|
||||
#define _xdg_mime_cache_ref XDG_RESERVED_ENTRY(cache_ref)
|
||||
#define _xdg_mime_cache_unref XDG_RESERVED_ENTRY(cache_unref)
|
||||
#define _xdg_mime_cache_get_max_buffer_extents XDG_RESERVED_ENTRY(cache_get_max_buffer_extents)
|
||||
#define _xdg_mime_cache_get_mime_type_for_data XDG_RESERVED_ENTRY(cache_get_mime_type_for_data)
|
||||
#define _xdg_mime_cache_get_mime_type_for_file XDG_RESERVED_ENTRY(cache_get_mime_type_for_file)
|
||||
#define _xdg_mime_cache_get_mime_type_from_file_name XDG_RESERVED_ENTRY(cache_get_mime_type_from_file_name)
|
||||
#define _xdg_mime_cache_get_mime_types_from_file_name XDG_RESERVED_ENTRY(cache_get_mime_types_from_file_name)
|
||||
#define _xdg_mime_cache_list_mime_parents XDG_RESERVED_ENTRY(cache_list_mime_parents)
|
||||
#define _xdg_mime_cache_mime_type_subclass XDG_RESERVED_ENTRY(cache_mime_type_subclass)
|
||||
#define _xdg_mime_cache_unalias_mime_type XDG_RESERVED_ENTRY(cache_unalias_mime_type)
|
||||
#define _xdg_mime_cache_get_icon XDG_RESERVED_ENTRY(cache_get_icon)
|
||||
#define _xdg_mime_cache_get_generic_icon XDG_RESERVED_ENTRY(cache_get_generic_icon)
|
||||
#define _xdg_mime_cache_glob_dump XDG_RESERVED_ENTRY(cache_glob_dump)
|
||||
#endif
|
||||
|
||||
extern XdgMimeCache **_caches;
|
||||
|
||||
XdgMimeCache *_xdg_mime_cache_new_from_file (const char *file_name);
|
||||
XdgMimeCache *_xdg_mime_cache_ref (XdgMimeCache *cache);
|
||||
void _xdg_mime_cache_unref (XdgMimeCache *cache);
|
||||
|
||||
|
||||
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);
|
||||
int _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
const char *_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name);
|
||||
int _xdg_mime_cache_is_valid_mime_type (const char *mime_type);
|
||||
int _xdg_mime_cache_mime_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_cache_media_type_equal (const char *mime_a,
|
||||
const char *mime_b);
|
||||
int _xdg_mime_cache_mime_type_subclass (const char *mime_a,
|
||||
const char *mime_b);
|
||||
char **_xdg_mime_cache_list_mime_parents (const char *mime);
|
||||
const char *_xdg_mime_cache_unalias_mime_type (const char *mime);
|
||||
int _xdg_mime_cache_get_max_buffer_extents (void);
|
||||
const char *_xdg_mime_cache_get_icon (const char *mime);
|
||||
const char *_xdg_mime_cache_get_generic_icon (const char *mime);
|
||||
void _xdg_mime_cache_glob_dump (void);
|
||||
|
||||
#endif /* __XDG_MIME_CACHE_H__ */
|
||||
691
xdgmime-source/src/xdgmimeglob.c
Normal file
691
xdgmime-source/src/xdgmimeglob.c
Normal file
@ -0,0 +1,691 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeglob.c: Private file. Datastructure for storing the globs.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeglob.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgGlobHashNode XdgGlobHashNode;
|
||||
typedef struct XdgGlobList XdgGlobList;
|
||||
|
||||
struct XdgGlobHashNode
|
||||
{
|
||||
xdg_unichar_t character;
|
||||
const char *mime_type;
|
||||
int weight;
|
||||
int case_sensitive;
|
||||
XdgGlobHashNode *next;
|
||||
XdgGlobHashNode *child;
|
||||
};
|
||||
struct XdgGlobList
|
||||
{
|
||||
const char *data;
|
||||
const char *mime_type;
|
||||
int weight;
|
||||
int case_sensitive;
|
||||
XdgGlobList *next;
|
||||
};
|
||||
|
||||
struct XdgGlobHash
|
||||
{
|
||||
XdgGlobList *literal_list;
|
||||
XdgGlobHashNode *simple_node;
|
||||
XdgGlobList *full_list;
|
||||
};
|
||||
|
||||
|
||||
/* XdgGlobList
|
||||
*/
|
||||
static XdgGlobList *
|
||||
_xdg_glob_list_new (void)
|
||||
{
|
||||
XdgGlobList *new_element;
|
||||
|
||||
new_element = calloc (1, sizeof (XdgGlobList));
|
||||
|
||||
return new_element;
|
||||
}
|
||||
|
||||
/* Frees glob_list and all of its children */
|
||||
static void
|
||||
_xdg_glob_list_free (XdgGlobList *glob_list)
|
||||
{
|
||||
XdgGlobList *ptr, *next;
|
||||
|
||||
ptr = glob_list;
|
||||
|
||||
while (ptr != NULL)
|
||||
{
|
||||
next = ptr->next;
|
||||
|
||||
if (ptr->data)
|
||||
free ((void *) ptr->data);
|
||||
if (ptr->mime_type)
|
||||
free ((void *) ptr->mime_type);
|
||||
free (ptr);
|
||||
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
|
||||
static XdgGlobList *
|
||||
_xdg_glob_list_append (XdgGlobList *glob_list,
|
||||
void *data,
|
||||
const char *mime_type,
|
||||
int weight,
|
||||
int case_sensitive)
|
||||
{
|
||||
XdgGlobList *new_element;
|
||||
XdgGlobList *tmp_element;
|
||||
|
||||
tmp_element = glob_list;
|
||||
while (tmp_element != NULL)
|
||||
{
|
||||
if (strcmp (tmp_element->data, data) == 0 &&
|
||||
strcmp (tmp_element->mime_type, mime_type) == 0)
|
||||
return glob_list;
|
||||
|
||||
tmp_element = tmp_element->next;
|
||||
}
|
||||
|
||||
new_element = _xdg_glob_list_new ();
|
||||
new_element->data = data;
|
||||
new_element->mime_type = mime_type;
|
||||
new_element->weight = weight;
|
||||
new_element->case_sensitive = case_sensitive;
|
||||
if (glob_list == NULL)
|
||||
return new_element;
|
||||
|
||||
tmp_element = glob_list;
|
||||
while (tmp_element->next != NULL)
|
||||
tmp_element = tmp_element->next;
|
||||
|
||||
tmp_element->next = new_element;
|
||||
|
||||
return glob_list;
|
||||
}
|
||||
|
||||
/* XdgGlobHashNode
|
||||
*/
|
||||
|
||||
static XdgGlobHashNode *
|
||||
_xdg_glob_hash_node_new (void)
|
||||
{
|
||||
XdgGlobHashNode *glob_hash_node;
|
||||
|
||||
glob_hash_node = calloc (1, sizeof (XdgGlobHashNode));
|
||||
|
||||
return glob_hash_node;
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node,
|
||||
int depth)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < depth; i++)
|
||||
printf (" ");
|
||||
|
||||
printf ("%c", (char)glob_hash_node->character);
|
||||
if (glob_hash_node->mime_type)
|
||||
printf (" - %s %d\n", glob_hash_node->mime_type, glob_hash_node->weight);
|
||||
else
|
||||
printf ("\n");
|
||||
if (glob_hash_node->child)
|
||||
_xdg_glob_hash_node_dump (glob_hash_node->child, depth + 1);
|
||||
if (glob_hash_node->next)
|
||||
_xdg_glob_hash_node_dump (glob_hash_node->next, depth);
|
||||
}
|
||||
|
||||
static XdgGlobHashNode *
|
||||
_xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
|
||||
xdg_unichar_t *text,
|
||||
const char *mime_type,
|
||||
int weight,
|
||||
int case_sensitive)
|
||||
{
|
||||
XdgGlobHashNode *node;
|
||||
xdg_unichar_t character;
|
||||
|
||||
character = text[0];
|
||||
|
||||
if ((glob_hash_node == NULL) ||
|
||||
(character < glob_hash_node->character))
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = glob_hash_node;
|
||||
glob_hash_node = node;
|
||||
}
|
||||
else if (character == glob_hash_node->character)
|
||||
{
|
||||
node = glob_hash_node;
|
||||
}
|
||||
else
|
||||
{
|
||||
XdgGlobHashNode *prev_node;
|
||||
int found_node = FALSE;
|
||||
|
||||
/* Look for the first character of text in glob_hash_node, and insert it if we
|
||||
* have to.*/
|
||||
prev_node = glob_hash_node;
|
||||
node = prev_node->next;
|
||||
|
||||
while (node != NULL)
|
||||
{
|
||||
if (character < node->character)
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = prev_node->next;
|
||||
prev_node->next = node;
|
||||
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
else if (character == node->character)
|
||||
{
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
prev_node = node;
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
if (! found_node)
|
||||
{
|
||||
node = _xdg_glob_hash_node_new ();
|
||||
node->character = character;
|
||||
node->next = prev_node->next;
|
||||
prev_node->next = node;
|
||||
}
|
||||
}
|
||||
|
||||
text++;
|
||||
if (*text == 0)
|
||||
{
|
||||
if (node->mime_type)
|
||||
{
|
||||
if (strcmp (node->mime_type, mime_type) != 0)
|
||||
{
|
||||
XdgGlobHashNode *child;
|
||||
int found_node = FALSE;
|
||||
|
||||
child = node->child;
|
||||
while (child && child->character == 0)
|
||||
{
|
||||
if (strcmp (child->mime_type, mime_type) == 0)
|
||||
{
|
||||
found_node = TRUE;
|
||||
break;
|
||||
}
|
||||
child = child->next;
|
||||
}
|
||||
|
||||
if (!found_node)
|
||||
{
|
||||
child = _xdg_glob_hash_node_new ();
|
||||
child->character = 0;
|
||||
child->mime_type = strdup (mime_type);
|
||||
child->weight = weight;
|
||||
child->case_sensitive = case_sensitive;
|
||||
child->child = NULL;
|
||||
child->next = node->child;
|
||||
node->child = child;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
node->mime_type = strdup (mime_type);
|
||||
node->weight = weight;
|
||||
node->case_sensitive = case_sensitive;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
node->child = _xdg_glob_hash_insert_ucs4 (node->child, text, mime_type, weight, case_sensitive);
|
||||
}
|
||||
return glob_hash_node;
|
||||
}
|
||||
|
||||
/* glob must be valid UTF-8 */
|
||||
static XdgGlobHashNode *
|
||||
_xdg_glob_hash_insert_text (XdgGlobHashNode *glob_hash_node,
|
||||
const char *text,
|
||||
const char *mime_type,
|
||||
int weight,
|
||||
int case_sensitive)
|
||||
{
|
||||
XdgGlobHashNode *node;
|
||||
xdg_unichar_t *unitext;
|
||||
int len;
|
||||
|
||||
unitext = _xdg_convert_to_ucs4 (text, &len);
|
||||
_xdg_reverse_ucs4 (unitext, len);
|
||||
node = _xdg_glob_hash_insert_ucs4 (glob_hash_node, unitext, mime_type, weight, case_sensitive);
|
||||
free (unitext);
|
||||
return node;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
const char *mime;
|
||||
int weight;
|
||||
} MimeWeight;
|
||||
|
||||
static int
|
||||
_xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
|
||||
const char *file_name,
|
||||
int len,
|
||||
int case_sensitive_check,
|
||||
MimeWeight mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
int n;
|
||||
XdgGlobHashNode *node;
|
||||
xdg_unichar_t character;
|
||||
|
||||
if (glob_hash_node == NULL)
|
||||
return 0;
|
||||
|
||||
character = file_name[len - 1];
|
||||
|
||||
for (node = glob_hash_node; node && character >= node->character; node = node->next)
|
||||
{
|
||||
if (character == node->character)
|
||||
{
|
||||
len--;
|
||||
n = 0;
|
||||
if (len > 0)
|
||||
{
|
||||
n = _xdg_glob_hash_node_lookup_file_name (node->child,
|
||||
file_name,
|
||||
len,
|
||||
case_sensitive_check,
|
||||
mime_types,
|
||||
n_mime_types);
|
||||
}
|
||||
if (n == 0)
|
||||
{
|
||||
if (node->mime_type &&
|
||||
(case_sensitive_check ||
|
||||
!node->case_sensitive))
|
||||
{
|
||||
mime_types[n].mime = node->mime_type;
|
||||
mime_types[n].weight = node->weight;
|
||||
n++;
|
||||
}
|
||||
node = node->child;
|
||||
while (n < n_mime_types && node && node->character == 0)
|
||||
{
|
||||
if (node->mime_type &&
|
||||
(case_sensitive_check ||
|
||||
!node->case_sensitive))
|
||||
{
|
||||
mime_types[n].mime = node->mime_type;
|
||||
mime_types[n].weight = node->weight;
|
||||
n++;
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int compare_mime_weight (const void *a, const void *b)
|
||||
{
|
||||
const MimeWeight *aa = (const MimeWeight *)a;
|
||||
const MimeWeight *bb = (const MimeWeight *)b;
|
||||
|
||||
return bb->weight - aa->weight;
|
||||
}
|
||||
|
||||
#define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
|
||||
static char *
|
||||
ascii_tolower (const char *str)
|
||||
{
|
||||
char *p, *lower;
|
||||
|
||||
lower = strdup (str);
|
||||
p = lower;
|
||||
while (*p != 0)
|
||||
{
|
||||
char c = *p;
|
||||
*p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
|
||||
}
|
||||
return lower;
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
|
||||
const char *file_name,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
XdgGlobList *list;
|
||||
int i, n;
|
||||
MimeWeight mimes[10];
|
||||
int n_mimes = 10;
|
||||
int len;
|
||||
char *lower_case;
|
||||
|
||||
/* First, check the literals */
|
||||
|
||||
assert (file_name != NULL && n_mime_types > 0);
|
||||
|
||||
n = 0;
|
||||
|
||||
lower_case = ascii_tolower (file_name);
|
||||
|
||||
for (list = glob_hash->literal_list; list; list = list->next)
|
||||
{
|
||||
if (strcmp ((const char *)list->data, file_name) == 0)
|
||||
{
|
||||
mime_types[0] = list->mime_type;
|
||||
free (lower_case);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
for (list = glob_hash->literal_list; list; list = list->next)
|
||||
{
|
||||
if (!list->case_sensitive &&
|
||||
strcmp ((const char *)list->data, lower_case) == 0)
|
||||
{
|
||||
mime_types[0] = list->mime_type;
|
||||
free (lower_case);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
len = strlen (file_name);
|
||||
n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE,
|
||||
mimes, n_mimes);
|
||||
if (n == 0)
|
||||
n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE,
|
||||
mimes, n_mimes);
|
||||
|
||||
if (n == 0)
|
||||
{
|
||||
for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
|
||||
{
|
||||
if (fnmatch ((const char *)list->data, file_name, 0) == 0)
|
||||
{
|
||||
mimes[n].mime = list->mime_type;
|
||||
mimes[n].weight = list->weight;
|
||||
n++;
|
||||
}
|
||||
}
|
||||
}
|
||||
free (lower_case);
|
||||
|
||||
qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
|
||||
|
||||
if (n_mime_types < n)
|
||||
n = n_mime_types;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
mime_types[i] = mimes[i].mime;
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* XdgGlobHash
|
||||
*/
|
||||
|
||||
XdgGlobHash *
|
||||
_xdg_glob_hash_new (void)
|
||||
{
|
||||
XdgGlobHash *glob_hash;
|
||||
|
||||
glob_hash = calloc (1, sizeof (XdgGlobHash));
|
||||
|
||||
return glob_hash;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
_xdg_glob_hash_free_nodes (XdgGlobHashNode *node)
|
||||
{
|
||||
if (node)
|
||||
{
|
||||
if (node->child)
|
||||
_xdg_glob_hash_free_nodes (node->child);
|
||||
if (node->next)
|
||||
_xdg_glob_hash_free_nodes (node->next);
|
||||
if (node->mime_type)
|
||||
free ((void *) node->mime_type);
|
||||
free (node);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_glob_hash_free (XdgGlobHash *glob_hash)
|
||||
{
|
||||
_xdg_glob_list_free (glob_hash->literal_list);
|
||||
_xdg_glob_list_free (glob_hash->full_list);
|
||||
_xdg_glob_hash_free_nodes (glob_hash->simple_node);
|
||||
free (glob_hash);
|
||||
}
|
||||
|
||||
XdgGlobType
|
||||
_xdg_glob_determine_type (const char *glob)
|
||||
{
|
||||
const char *ptr;
|
||||
int maybe_in_simple_glob = FALSE;
|
||||
int first_char = TRUE;
|
||||
|
||||
ptr = glob;
|
||||
|
||||
while (*ptr != '\0')
|
||||
{
|
||||
if (*ptr == '*' && first_char)
|
||||
maybe_in_simple_glob = TRUE;
|
||||
else if (*ptr == '\\' || *ptr == '[' || *ptr == '?' || *ptr == '*')
|
||||
return XDG_GLOB_FULL;
|
||||
|
||||
first_char = FALSE;
|
||||
ptr = _xdg_utf8_next_char (ptr);
|
||||
}
|
||||
if (maybe_in_simple_glob)
|
||||
return XDG_GLOB_SIMPLE;
|
||||
else
|
||||
return XDG_GLOB_LITERAL;
|
||||
}
|
||||
|
||||
/* glob must be valid UTF-8 */
|
||||
void
|
||||
_xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
|
||||
const char *glob,
|
||||
const char *mime_type,
|
||||
int weight,
|
||||
int case_sensitive)
|
||||
{
|
||||
XdgGlobType type;
|
||||
|
||||
assert (glob_hash != NULL);
|
||||
assert (glob != NULL);
|
||||
|
||||
type = _xdg_glob_determine_type (glob);
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case XDG_GLOB_LITERAL:
|
||||
glob_hash->literal_list = _xdg_glob_list_append (glob_hash->literal_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
|
||||
break;
|
||||
case XDG_GLOB_SIMPLE:
|
||||
glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, mime_type, weight, case_sensitive);
|
||||
break;
|
||||
case XDG_GLOB_FULL:
|
||||
glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_glob_hash_dump (XdgGlobHash *glob_hash)
|
||||
{
|
||||
XdgGlobList *list;
|
||||
printf ("LITERAL STRINGS\n");
|
||||
if (!glob_hash || glob_hash->literal_list == NULL)
|
||||
{
|
||||
printf (" None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (list = glob_hash->literal_list; list; list = list->next)
|
||||
printf (" %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
|
||||
}
|
||||
printf ("\nSIMPLE GLOBS\n");
|
||||
if (!glob_hash || glob_hash->simple_node == NULL)
|
||||
{
|
||||
printf (" None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
_xdg_glob_hash_node_dump (glob_hash->simple_node, 4);
|
||||
}
|
||||
|
||||
printf ("\nFULL GLOBS\n");
|
||||
if (!glob_hash || glob_hash->full_list == NULL)
|
||||
{
|
||||
printf (" None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (list = glob_hash->full_list; list; list = list->next)
|
||||
printf (" %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
|
||||
const char *file_name,
|
||||
int version_two)
|
||||
{
|
||||
FILE *glob_file;
|
||||
char line[255];
|
||||
char *p;
|
||||
|
||||
glob_file = fopen (file_name, "r");
|
||||
|
||||
if (glob_file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
while (fgets (line, 255, glob_file) != NULL)
|
||||
{
|
||||
char *colon;
|
||||
char *mimetype, *glob, *end;
|
||||
int weight;
|
||||
int case_sensitive;
|
||||
|
||||
if (line[0] == '#' || line[0] == 0)
|
||||
continue;
|
||||
|
||||
end = line + strlen(line) - 1;
|
||||
if (*end == '\n')
|
||||
*end = 0;
|
||||
|
||||
p = line;
|
||||
if (version_two)
|
||||
{
|
||||
colon = strchr (p, ':');
|
||||
if (colon == NULL)
|
||||
continue;
|
||||
*colon = 0;
|
||||
weight = atoi (p);
|
||||
p = colon + 1;
|
||||
}
|
||||
else
|
||||
weight = 50;
|
||||
|
||||
colon = strchr (p, ':');
|
||||
if (colon == NULL)
|
||||
continue;
|
||||
*colon = 0;
|
||||
|
||||
mimetype = p;
|
||||
p = colon + 1;
|
||||
glob = p;
|
||||
case_sensitive = FALSE;
|
||||
|
||||
colon = strchr (p, ':');
|
||||
if (version_two && colon != NULL)
|
||||
{
|
||||
char *flag;
|
||||
|
||||
/* We got flags */
|
||||
*colon = 0;
|
||||
p = colon + 1;
|
||||
|
||||
/* Flags end at next colon */
|
||||
colon = strchr (p, ':');
|
||||
if (colon != NULL)
|
||||
*colon = 0;
|
||||
|
||||
flag = strstr (p, "cs");
|
||||
if (flag != NULL &&
|
||||
/* Start or after comma */
|
||||
(flag == p ||
|
||||
flag[-1] == ',') &&
|
||||
/* ends with comma or end of string */
|
||||
(flag[2] == 0 ||
|
||||
flag[2] == ','))
|
||||
case_sensitive = TRUE;
|
||||
}
|
||||
|
||||
_xdg_glob_hash_append_glob (glob_hash, glob, mimetype, weight, case_sensitive);
|
||||
}
|
||||
|
||||
fclose (glob_file);
|
||||
}
|
||||
70
xdgmime-source/src/xdgmimeglob.h
Normal file
70
xdgmime-source/src/xdgmimeglob.h
Normal file
@ -0,0 +1,70 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeglob.h: Private file. Datastructure for storing the globs.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_GLOB_H__
|
||||
#define __XDG_MIME_GLOB_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgGlobHash XdgGlobHash;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
XDG_GLOB_LITERAL, /* Makefile */
|
||||
XDG_GLOB_SIMPLE, /* *.gif */
|
||||
XDG_GLOB_FULL /* x*.[ch] */
|
||||
} XdgGlobType;
|
||||
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_glob_read_from_file XDG_RESERVED_ENTRY(glob_read_from_file)
|
||||
#define _xdg_glob_hash_new XDG_RESERVED_ENTRY(hash_new)
|
||||
#define _xdg_glob_hash_free XDG_RESERVED_ENTRY(hash_free)
|
||||
#define _xdg_glob_hash_lookup_file_name XDG_RESERVED_ENTRY(hash_lookup_file_name)
|
||||
#define _xdg_glob_hash_append_glob XDG_RESERVED_ENTRY(hash_append_glob)
|
||||
#define _xdg_glob_determine_type XDG_RESERVED_ENTRY(determine_type)
|
||||
#define _xdg_glob_hash_dump XDG_RESERVED_ENTRY(hash_dump)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
|
||||
const char *file_name,
|
||||
int version_two);
|
||||
XdgGlobHash *_xdg_glob_hash_new (void);
|
||||
void _xdg_glob_hash_free (XdgGlobHash *glob_hash);
|
||||
int _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
|
||||
const char *text,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
void _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
|
||||
const char *glob,
|
||||
const char *mime_type,
|
||||
int weight,
|
||||
int case_sensitive);
|
||||
XdgGlobType _xdg_glob_determine_type (const char *glob);
|
||||
void _xdg_glob_hash_dump (XdgGlobHash *glob_hash);
|
||||
|
||||
#endif /* __XDG_MIME_GLOB_H__ */
|
||||
183
xdgmime-source/src/xdgmimeicon.c
Normal file
183
xdgmime-source/src/xdgmimeicon.c
Normal file
@ -0,0 +1,183 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeicon.c: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2008 Red Hat, Inc.
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeicon.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgIcon XdgIcon;
|
||||
|
||||
struct XdgIcon
|
||||
{
|
||||
char *mime_type;
|
||||
char *icon_name;
|
||||
};
|
||||
|
||||
struct XdgIconList
|
||||
{
|
||||
struct XdgIcon *icons;
|
||||
int n_icons;
|
||||
};
|
||||
|
||||
XdgIconList *
|
||||
_xdg_mime_icon_list_new (void)
|
||||
{
|
||||
XdgIconList *list;
|
||||
|
||||
list = malloc (sizeof (XdgIconList));
|
||||
|
||||
list->icons = NULL;
|
||||
list->n_icons = 0;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_icon_list_free (XdgIconList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->icons)
|
||||
{
|
||||
for (i = 0; i < list->n_icons; i++)
|
||||
{
|
||||
free (list->icons[i].mime_type);
|
||||
free (list->icons[i].icon_name);
|
||||
}
|
||||
free (list->icons);
|
||||
}
|
||||
free (list);
|
||||
}
|
||||
|
||||
static int
|
||||
icon_entry_cmp (const void *v1, const void *v2)
|
||||
{
|
||||
return strcmp (((XdgIcon *)v1)->mime_type, ((XdgIcon *)v2)->mime_type);
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_icon_list_lookup (XdgIconList *list,
|
||||
const char *mime_type)
|
||||
{
|
||||
XdgIcon *entry;
|
||||
XdgIcon key;
|
||||
|
||||
if (list->n_icons > 0)
|
||||
{
|
||||
key.mime_type = (char *)mime_type;
|
||||
key.icon_name = NULL;
|
||||
|
||||
entry = bsearch (&key, list->icons, list->n_icons,
|
||||
sizeof (XdgIcon), icon_entry_cmp);
|
||||
if (entry)
|
||||
return entry->icon_name;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_icon_read_from_file (XdgIconList *list,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int alloc;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
|
||||
if (file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
alloc = list->n_icons + 16;
|
||||
list->icons = realloc (list->icons, alloc * sizeof (XdgIcon));
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
char *sep;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
sep = strchr (line, ':');
|
||||
if (sep == NULL)
|
||||
continue;
|
||||
*(sep++) = '\000';
|
||||
sep[strlen (sep) -1] = '\000';
|
||||
if (list->n_icons == alloc)
|
||||
{
|
||||
alloc <<= 1;
|
||||
list->icons = realloc (list->icons,
|
||||
alloc * sizeof (XdgIcon));
|
||||
}
|
||||
list->icons[list->n_icons].mime_type = strdup (line);
|
||||
list->icons[list->n_icons].icon_name = strdup (sep);
|
||||
list->n_icons++;
|
||||
}
|
||||
list->icons = realloc (list->icons,
|
||||
list->n_icons * sizeof (XdgIcon));
|
||||
|
||||
fclose (file);
|
||||
|
||||
if (list->n_icons > 1)
|
||||
qsort (list->icons, list->n_icons,
|
||||
sizeof (XdgIcon), icon_entry_cmp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_icon_list_dump (XdgIconList *list)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (list->icons)
|
||||
{
|
||||
for (i = 0; i < list->n_icons; i++)
|
||||
{
|
||||
printf ("%s %s\n",
|
||||
list->icons[i].mime_type,
|
||||
list->icons[i].icon_name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
50
xdgmime-source/src/xdgmimeicon.h
Normal file
50
xdgmime-source/src/xdgmimeicon.h
Normal file
@ -0,0 +1,50 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeicon.h: Private file. Datastructure for storing the aliases.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2008 Red Hat, Inc.
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_ICON_H__
|
||||
#define __XDG_MIME_ICON_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgIconList XdgIconList;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_icon_read_from_file XDG_ENTRY(icon_read_from_file)
|
||||
#define _xdg_mime_icon_list_new XDG_ENTRY(icon_list_new)
|
||||
#define _xdg_mime_icon_list_free XDG_ENTRY(icon_list_free)
|
||||
#define _xdg_mime_icon_list_lookup XDG_ENTRY(icon_list_lookup)
|
||||
#define _xdg_mime_icon_list_dump XDG_ENTRY(icon_list_dump)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_icon_read_from_file (XdgIconList *list,
|
||||
const char *file_name);
|
||||
XdgIconList *_xdg_mime_icon_list_new (void);
|
||||
void _xdg_mime_icon_list_free (XdgIconList *list);
|
||||
const char *_xdg_mime_icon_list_lookup (XdgIconList *list,
|
||||
const char *mime);
|
||||
void _xdg_mime_icon_list_dump (XdgIconList *list);
|
||||
|
||||
#endif /* __XDG_MIME_ICON_H__ */
|
||||
206
xdgmime-source/src/xdgmimeint.c
Normal file
206
xdgmime-source/src/xdgmimeint.c
Normal file
@ -0,0 +1,206 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeint.c: Internal defines and functions.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeint.h"
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
static const char _xdg_utf8_skip_data[256] = {
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
|
||||
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
|
||||
};
|
||||
|
||||
const char * const _xdg_utf8_skip = _xdg_utf8_skip_data;
|
||||
|
||||
|
||||
|
||||
/* Returns the number of unprocessed characters. */
|
||||
xdg_unichar_t
|
||||
_xdg_utf8_to_ucs4(const char *source)
|
||||
{
|
||||
xdg_unichar_t ucs32;
|
||||
if( ! ( *source & 0x80 ) )
|
||||
{
|
||||
ucs32 = *source;
|
||||
}
|
||||
else
|
||||
{
|
||||
int bytelength = 0;
|
||||
xdg_unichar_t result;
|
||||
if ( ! (*source & 0x40) )
|
||||
{
|
||||
ucs32 = *source;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( ! (*source & 0x20) )
|
||||
{
|
||||
result = *source++ & 0x1F;
|
||||
bytelength = 2;
|
||||
}
|
||||
else if ( ! (*source & 0x10) )
|
||||
{
|
||||
result = *source++ & 0x0F;
|
||||
bytelength = 3;
|
||||
}
|
||||
else if ( ! (*source & 0x08) )
|
||||
{
|
||||
result = *source++ & 0x07;
|
||||
bytelength = 4;
|
||||
}
|
||||
else if ( ! (*source & 0x04) )
|
||||
{
|
||||
result = *source++ & 0x03;
|
||||
bytelength = 5;
|
||||
}
|
||||
else if ( ! (*source & 0x02) )
|
||||
{
|
||||
result = *source++ & 0x01;
|
||||
bytelength = 6;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = *source++;
|
||||
bytelength = 1;
|
||||
}
|
||||
|
||||
for ( bytelength --; bytelength > 0; bytelength -- )
|
||||
{
|
||||
result <<= 6;
|
||||
result |= *source++ & 0x3F;
|
||||
}
|
||||
ucs32 = result;
|
||||
}
|
||||
}
|
||||
return ucs32;
|
||||
}
|
||||
|
||||
|
||||
/* hullo. this is great code. don't rewrite it */
|
||||
|
||||
xdg_unichar_t
|
||||
_xdg_ucs4_to_lower (xdg_unichar_t source)
|
||||
{
|
||||
/* FIXME: Do a real to_upper sometime */
|
||||
/* CaseFolding-3.2.0.txt has a table of rules. */
|
||||
if ((source & 0xFF) == source)
|
||||
return (xdg_unichar_t) tolower ((unsigned char) source);
|
||||
return source;
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_utf8_validate (const char *source)
|
||||
{
|
||||
/* FIXME: actually write */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_get_base_name (const char *file_name)
|
||||
{
|
||||
const char *base_name;
|
||||
|
||||
if (file_name == NULL)
|
||||
return NULL;
|
||||
|
||||
base_name = strrchr (file_name, '/');
|
||||
|
||||
if (base_name == NULL)
|
||||
return file_name;
|
||||
else
|
||||
return base_name + 1;
|
||||
}
|
||||
|
||||
xdg_unichar_t *
|
||||
_xdg_convert_to_ucs4 (const char *source, int *len)
|
||||
{
|
||||
xdg_unichar_t *out;
|
||||
int i;
|
||||
const char *p;
|
||||
|
||||
out = malloc (sizeof (xdg_unichar_t) * (strlen (source) + 1));
|
||||
|
||||
p = source;
|
||||
i = 0;
|
||||
while (*p)
|
||||
{
|
||||
out[i++] = _xdg_utf8_to_ucs4 (p);
|
||||
p = _xdg_utf8_next_char (p);
|
||||
}
|
||||
out[i] = 0;
|
||||
*len = i;
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_reverse_ucs4 (xdg_unichar_t *source, int len)
|
||||
{
|
||||
xdg_unichar_t c;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len - i - 1; i++)
|
||||
{
|
||||
c = source[i];
|
||||
source[i] = source[len - i - 1];
|
||||
source[len - i - 1] = c;
|
||||
}
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_binary_or_text_fallback(const void *data, size_t len)
|
||||
{
|
||||
unsigned char *chardata;
|
||||
size_t i;
|
||||
|
||||
chardata = (unsigned char *) data;
|
||||
for (i = 0; i < 128 && i < len; ++i)
|
||||
{
|
||||
if (chardata[i] < 32 && chardata[i] != 9 && chardata[i] != 10 && chardata[i] != 13)
|
||||
return XDG_MIME_TYPE_UNKNOWN; /* binary data */
|
||||
}
|
||||
|
||||
return XDG_MIME_TYPE_TEXTPLAIN;
|
||||
}
|
||||
78
xdgmime-source/src/xdgmimeint.h
Normal file
78
xdgmime-source/src/xdgmimeint.h
Normal file
@ -0,0 +1,78 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeint.h: Internal defines and functions.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_INT_H__
|
||||
#define __XDG_MIME_INT_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
/* FIXME: Needs to be configure check */
|
||||
typedef unsigned int xdg_unichar_t;
|
||||
typedef unsigned char xdg_uchar8_t;
|
||||
typedef unsigned short xdg_uint16_t;
|
||||
typedef unsigned int xdg_uint32_t;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_utf8_skip XDG_RESERVED_ENTRY(utf8_skip)
|
||||
#define _xdg_utf8_to_ucs4 XDG_RESERVED_ENTRY(utf8_to_ucs4)
|
||||
#define _xdg_ucs4_to_lower XDG_RESERVED_ENTRY(ucs4_to_lower)
|
||||
#define _xdg_utf8_validate XDG_RESERVED_ENTRY(utf8_validate)
|
||||
#define _xdg_get_base_name XDG_RESERVED_ENTRY(get_base_name)
|
||||
#define _xdg_convert_to_ucs4 XDG_RESERVED_ENTRY(convert_to_ucs4)
|
||||
#define _xdg_reverse_ucs4 XDG_RESERVED_ENTRY(reverse_ucs4)
|
||||
#endif
|
||||
|
||||
#define SWAP_BE16_TO_LE16(val) (xdg_uint16_t)(((xdg_uint16_t)(val) << 8)|((xdg_uint16_t)(val) >> 8))
|
||||
|
||||
#define SWAP_BE32_TO_LE32(val) (xdg_uint32_t)((((xdg_uint32_t)(val) & 0xFF000000U) >> 24) | \
|
||||
(((xdg_uint32_t)(val) & 0x00FF0000U) >> 8) | \
|
||||
(((xdg_uint32_t)(val) & 0x0000FF00U) << 8) | \
|
||||
(((xdg_uint32_t)(val) & 0x000000FFU) << 24))
|
||||
/* UTF-8 utils
|
||||
*/
|
||||
extern const char *const _xdg_utf8_skip;
|
||||
#define _xdg_utf8_next_char(p) (char *)((p) + _xdg_utf8_skip[*(unsigned char *)(p)])
|
||||
#define _xdg_utf8_char_size(p) (int) (_xdg_utf8_skip[*(unsigned char *)(p)])
|
||||
|
||||
xdg_unichar_t _xdg_utf8_to_ucs4 (const char *source);
|
||||
xdg_unichar_t _xdg_ucs4_to_lower (xdg_unichar_t source);
|
||||
int _xdg_utf8_validate (const char *source);
|
||||
xdg_unichar_t *_xdg_convert_to_ucs4 (const char *source, int *len);
|
||||
void _xdg_reverse_ucs4 (xdg_unichar_t *source, int len);
|
||||
const char *_xdg_get_base_name (const char *file_name);
|
||||
const char *_xdg_binary_or_text_fallback(const void *data, size_t len);
|
||||
|
||||
#endif /* __XDG_MIME_INT_H__ */
|
||||
816
xdgmime-source/src/xdgmimemagic.c
Normal file
816
xdgmime-source/src/xdgmimemagic.c
Normal file
@ -0,0 +1,816 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimemagic.: Private file. Datastructure for storing magic files.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include "xdgmimemagic.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
#if !defined getc_unlocked && !defined HAVE_GETC_UNLOCKED
|
||||
# define getc_unlocked(fp) getc (fp)
|
||||
#endif
|
||||
|
||||
typedef struct XdgMimeMagicMatch XdgMimeMagicMatch;
|
||||
typedef struct XdgMimeMagicMatchlet XdgMimeMagicMatchlet;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
XDG_MIME_MAGIC_SECTION,
|
||||
XDG_MIME_MAGIC_MAGIC,
|
||||
XDG_MIME_MAGIC_ERROR,
|
||||
XDG_MIME_MAGIC_EOF
|
||||
} XdgMimeMagicState;
|
||||
|
||||
struct XdgMimeMagicMatch
|
||||
{
|
||||
const char *mime_type;
|
||||
int priority;
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
XdgMimeMagicMatch *next;
|
||||
};
|
||||
|
||||
|
||||
struct XdgMimeMagicMatchlet
|
||||
{
|
||||
int indent;
|
||||
int offset;
|
||||
unsigned int value_length;
|
||||
unsigned char *value;
|
||||
unsigned char *mask;
|
||||
unsigned int range_length;
|
||||
unsigned int word_size;
|
||||
XdgMimeMagicMatchlet *next;
|
||||
};
|
||||
|
||||
|
||||
struct XdgMimeMagic
|
||||
{
|
||||
XdgMimeMagicMatch *match_list;
|
||||
int max_extent;
|
||||
};
|
||||
|
||||
static XdgMimeMagicMatch *
|
||||
_xdg_mime_magic_match_new (void)
|
||||
{
|
||||
return calloc (1, sizeof (XdgMimeMagicMatch));
|
||||
}
|
||||
|
||||
|
||||
static XdgMimeMagicMatchlet *
|
||||
_xdg_mime_magic_matchlet_new (void)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
matchlet = malloc (sizeof (XdgMimeMagicMatchlet));
|
||||
|
||||
matchlet->indent = 0;
|
||||
matchlet->offset = 0;
|
||||
matchlet->value_length = 0;
|
||||
matchlet->value = NULL;
|
||||
matchlet->mask = NULL;
|
||||
matchlet->range_length = 1;
|
||||
matchlet->word_size = 1;
|
||||
matchlet->next = NULL;
|
||||
|
||||
return matchlet;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_matchlet_free (XdgMimeMagicMatchlet *mime_magic_matchlet)
|
||||
{
|
||||
if (mime_magic_matchlet)
|
||||
{
|
||||
if (mime_magic_matchlet->next)
|
||||
_xdg_mime_magic_matchlet_free (mime_magic_matchlet->next);
|
||||
if (mime_magic_matchlet->value)
|
||||
free (mime_magic_matchlet->value);
|
||||
if (mime_magic_matchlet->mask)
|
||||
free (mime_magic_matchlet->mask);
|
||||
free (mime_magic_matchlet);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Frees mime_magic_match and the remainder of its list
|
||||
*/
|
||||
static void
|
||||
_xdg_mime_magic_match_free (XdgMimeMagicMatch *mime_magic_match)
|
||||
{
|
||||
XdgMimeMagicMatch *ptr, *next;
|
||||
|
||||
ptr = mime_magic_match;
|
||||
while (ptr)
|
||||
{
|
||||
next = ptr->next;
|
||||
|
||||
if (ptr->mime_type)
|
||||
free ((void *) ptr->mime_type);
|
||||
if (ptr->matchlet)
|
||||
_xdg_mime_magic_matchlet_free (ptr->matchlet);
|
||||
free (ptr);
|
||||
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
|
||||
/* Reads in a hunk of data until a newline character or a '\000' is hit. The
|
||||
* returned string is null terminated, and doesn't include the newline.
|
||||
*/
|
||||
static unsigned char *
|
||||
_xdg_mime_magic_read_to_newline (FILE *magic_file,
|
||||
int *end_of_file)
|
||||
{
|
||||
unsigned char *retval;
|
||||
int c;
|
||||
int len, pos;
|
||||
|
||||
len = 128;
|
||||
pos = 0;
|
||||
retval = malloc (len);
|
||||
*end_of_file = FALSE;
|
||||
|
||||
while (TRUE)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
*end_of_file = TRUE;
|
||||
break;
|
||||
}
|
||||
if (c == '\n' || c == '\000')
|
||||
break;
|
||||
retval[pos++] = (unsigned char) c;
|
||||
if (pos % 128 == 127)
|
||||
{
|
||||
len = len + 128;
|
||||
retval = realloc (retval, len);
|
||||
}
|
||||
}
|
||||
|
||||
retval[pos] = '\000';
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Returns the number read from the file, or -1 if no number could be read.
|
||||
*/
|
||||
static int
|
||||
_xdg_mime_magic_read_a_number (FILE *magic_file,
|
||||
int *end_of_file)
|
||||
{
|
||||
/* LONG_MAX is about 20 characters on my system */
|
||||
#define MAX_NUMBER_SIZE 30
|
||||
char number_string[MAX_NUMBER_SIZE + 1];
|
||||
int pos = 0;
|
||||
int c;
|
||||
long retval = -1;
|
||||
|
||||
while (TRUE)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
|
||||
if (c == EOF)
|
||||
{
|
||||
*end_of_file = TRUE;
|
||||
break;
|
||||
}
|
||||
if (! isdigit (c))
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
break;
|
||||
}
|
||||
number_string[pos] = (char) c;
|
||||
pos++;
|
||||
if (pos == MAX_NUMBER_SIZE)
|
||||
break;
|
||||
}
|
||||
if (pos > 0)
|
||||
{
|
||||
number_string[pos] = '\000';
|
||||
errno = 0;
|
||||
retval = strtol (number_string, NULL, 10);
|
||||
|
||||
if ((retval < INT_MIN) || (retval > INT_MAX) || (errno != 0))
|
||||
return -1;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Headers are of the format:
|
||||
* [<priority>:<mime-type>]
|
||||
*/
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_header (FILE *magic_file, XdgMimeMagicMatch *match)
|
||||
{
|
||||
int c;
|
||||
char *buffer;
|
||||
char *end_ptr;
|
||||
int end_of_file = 0;
|
||||
|
||||
assert (magic_file != NULL);
|
||||
assert (match != NULL);
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c != '[')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
match->priority = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (match->priority == -1)
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c != ':')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
buffer = (char *)_xdg_mime_magic_read_to_newline (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
free (buffer);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
|
||||
end_ptr = buffer;
|
||||
while (*end_ptr != ']' && *end_ptr != '\000' && *end_ptr != '\n')
|
||||
end_ptr++;
|
||||
if (*end_ptr != ']')
|
||||
{
|
||||
free (buffer);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
*end_ptr = '\000';
|
||||
|
||||
match->mime_type = strdup (buffer);
|
||||
free (buffer);
|
||||
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
}
|
||||
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_error (FILE *magic_file)
|
||||
{
|
||||
int c;
|
||||
|
||||
while (1)
|
||||
{
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (c == '\n')
|
||||
return XDG_MIME_MAGIC_SECTION;
|
||||
}
|
||||
}
|
||||
|
||||
/* Headers are of the format:
|
||||
* [ indent ] ">" start-offset "=" value
|
||||
* [ "&" mask ] [ "~" word-size ] [ "+" range-length ] "\n"
|
||||
*/
|
||||
static XdgMimeMagicState
|
||||
_xdg_mime_magic_parse_magic_line (FILE *magic_file,
|
||||
XdgMimeMagicMatch *match)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
int c;
|
||||
int end_of_file;
|
||||
int indent = 0;
|
||||
size_t bytes_read;
|
||||
|
||||
assert (magic_file != NULL);
|
||||
|
||||
/* Sniff the buffer to make sure it's a valid line */
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else if (c == '[')
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
return XDG_MIME_MAGIC_SECTION;
|
||||
}
|
||||
else if (c == '\n')
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
|
||||
/* At this point, it must be a digit or a '>' */
|
||||
end_of_file = FALSE;
|
||||
if (isdigit (c))
|
||||
{
|
||||
ungetc (c, magic_file);
|
||||
indent = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
if (indent == -1)
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
|
||||
if (c != '>')
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
|
||||
matchlet = _xdg_mime_magic_matchlet_new ();
|
||||
matchlet->indent = indent;
|
||||
matchlet->offset = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->offset == -1)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
else if (c != '=')
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
/* Next two bytes determine how long the value is */
|
||||
matchlet->value_length = 0;
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
matchlet->value_length = c & 0xFF;
|
||||
matchlet->value_length = matchlet->value_length << 8;
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == EOF)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
matchlet->value_length = matchlet->value_length + (c & 0xFF);
|
||||
|
||||
matchlet->value = malloc (matchlet->value_length);
|
||||
|
||||
/* OOM */
|
||||
if (matchlet->value == NULL)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file);
|
||||
if (bytes_read != (size_t) matchlet->value_length)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (feof (magic_file))
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
c = getc_unlocked (magic_file);
|
||||
if (c == '&')
|
||||
{
|
||||
matchlet->mask = malloc (matchlet->value_length);
|
||||
/* OOM */
|
||||
if (matchlet->mask == NULL)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file);
|
||||
if (bytes_read != (size_t) matchlet->value_length)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (feof (magic_file))
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
else
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
if (c == '~')
|
||||
{
|
||||
matchlet->word_size = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->word_size != 0 &&
|
||||
matchlet->word_size != 1 &&
|
||||
matchlet->word_size != 2 &&
|
||||
matchlet->word_size != 4)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
if (c == '+')
|
||||
{
|
||||
matchlet->range_length = _xdg_mime_magic_read_a_number (magic_file, &end_of_file);
|
||||
if (end_of_file)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
}
|
||||
if (matchlet->range_length == (unsigned int) -1)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
c = getc_unlocked (magic_file);
|
||||
}
|
||||
|
||||
|
||||
if (c == '\n')
|
||||
{
|
||||
/* We clean up the matchlet, byte swapping if needed */
|
||||
if (matchlet->word_size > 1)
|
||||
{
|
||||
unsigned int i;
|
||||
if (matchlet->value_length % matchlet->word_size != 0)
|
||||
{
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
/* FIXME: need to get this defined in a <config.h> style file */
|
||||
#if LITTLE_ENDIAN
|
||||
for (i = 0; i < matchlet->value_length; i = i + matchlet->word_size)
|
||||
{
|
||||
if (matchlet->word_size == 2)
|
||||
*((xdg_uint16_t *) matchlet->value + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->value + i)));
|
||||
else if (matchlet->word_size == 4)
|
||||
*((xdg_uint32_t *) matchlet->value + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->value + i)));
|
||||
if (matchlet->mask)
|
||||
{
|
||||
if (matchlet->word_size == 2)
|
||||
*((xdg_uint16_t *) matchlet->mask + i) = SWAP_BE16_TO_LE16 (*((xdg_uint16_t *) (matchlet->mask + i)));
|
||||
else if (matchlet->word_size == 4)
|
||||
*((xdg_uint32_t *) matchlet->mask + i) = SWAP_BE32_TO_LE32 (*((xdg_uint32_t *) (matchlet->mask + i)));
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
matchlet->next = match->matchlet;
|
||||
match->matchlet = matchlet;
|
||||
|
||||
|
||||
return XDG_MIME_MAGIC_MAGIC;
|
||||
}
|
||||
|
||||
_xdg_mime_magic_matchlet_free (matchlet);
|
||||
if (c == EOF)
|
||||
return XDG_MIME_MAGIC_EOF;
|
||||
|
||||
return XDG_MIME_MAGIC_ERROR;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_matchlet_compare_to_data (XdgMimeMagicMatchlet *matchlet,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
unsigned int i, j;
|
||||
for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++)
|
||||
{
|
||||
int valid_matchlet = TRUE;
|
||||
|
||||
if (i + matchlet->value_length > len)
|
||||
return FALSE;
|
||||
|
||||
if (matchlet->mask)
|
||||
{
|
||||
for (j = 0; j < matchlet->value_length; j++)
|
||||
{
|
||||
if ((matchlet->value[j] & matchlet->mask[j]) !=
|
||||
((((unsigned char *) data)[j + i]) & matchlet->mask[j]))
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (j = 0; j < matchlet->value_length; j++)
|
||||
{
|
||||
if (matchlet->value[j] != ((unsigned char *) data)[j + i])
|
||||
{
|
||||
valid_matchlet = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (valid_matchlet)
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_matchlet_compare_level (XdgMimeMagicMatchlet *matchlet,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int indent)
|
||||
{
|
||||
while ((matchlet != NULL) && (matchlet->indent == indent))
|
||||
{
|
||||
if (_xdg_mime_magic_matchlet_compare_to_data (matchlet, data, len))
|
||||
{
|
||||
if ((matchlet->next == NULL) ||
|
||||
(matchlet->next->indent <= indent))
|
||||
return TRUE;
|
||||
|
||||
if (_xdg_mime_magic_matchlet_compare_level (matchlet->next,
|
||||
data,
|
||||
len,
|
||||
indent + 1))
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
matchlet = matchlet->next;
|
||||
}
|
||||
while (matchlet && matchlet->indent > indent);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
_xdg_mime_magic_match_compare_to_data (XdgMimeMagicMatch *match,
|
||||
const void *data,
|
||||
size_t len)
|
||||
{
|
||||
return _xdg_mime_magic_matchlet_compare_level (match->matchlet, data, len, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_insert_match (XdgMimeMagic *mime_magic,
|
||||
XdgMimeMagicMatch *match)
|
||||
{
|
||||
XdgMimeMagicMatch *list;
|
||||
|
||||
if (mime_magic->match_list == NULL)
|
||||
{
|
||||
mime_magic->match_list = match;
|
||||
return;
|
||||
}
|
||||
|
||||
if (match->priority > mime_magic->match_list->priority)
|
||||
{
|
||||
match->next = mime_magic->match_list;
|
||||
mime_magic->match_list = match;
|
||||
return;
|
||||
}
|
||||
|
||||
list = mime_magic->match_list;
|
||||
while (list->next != NULL)
|
||||
{
|
||||
if (list->next->priority < match->priority)
|
||||
{
|
||||
match->next = list->next;
|
||||
list->next = match;
|
||||
return;
|
||||
}
|
||||
list = list->next;
|
||||
}
|
||||
list->next = match;
|
||||
match->next = NULL;
|
||||
}
|
||||
|
||||
XdgMimeMagic *
|
||||
_xdg_mime_magic_new (void)
|
||||
{
|
||||
return calloc (1, sizeof (XdgMimeMagic));
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_magic_free (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
if (mime_magic) {
|
||||
_xdg_mime_magic_match_free (mime_magic->match_list);
|
||||
free (mime_magic);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
_xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
return mime_magic->max_extent;
|
||||
}
|
||||
|
||||
const char *
|
||||
_xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int *result_prio,
|
||||
const char *mime_types[],
|
||||
int n_mime_types)
|
||||
{
|
||||
XdgMimeMagicMatch *match;
|
||||
const char *mime_type;
|
||||
int n;
|
||||
int prio;
|
||||
|
||||
prio = 0;
|
||||
mime_type = NULL;
|
||||
for (match = mime_magic->match_list; match; match = match->next)
|
||||
{
|
||||
if (_xdg_mime_magic_match_compare_to_data (match, data, len))
|
||||
{
|
||||
prio = match->priority;
|
||||
mime_type = match->mime_type;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n] &&
|
||||
_xdg_mime_mime_type_equal (mime_types[n], match->mime_type))
|
||||
mime_types[n] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mime_type == NULL)
|
||||
{
|
||||
for (n = 0; n < n_mime_types; n++)
|
||||
{
|
||||
if (mime_types[n])
|
||||
mime_type = mime_types[n];
|
||||
}
|
||||
}
|
||||
|
||||
if (result_prio)
|
||||
*result_prio = prio;
|
||||
|
||||
return mime_type;
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_update_mime_magic_extents (XdgMimeMagic *mime_magic)
|
||||
{
|
||||
XdgMimeMagicMatch *match;
|
||||
int max_extent = 0;
|
||||
|
||||
for (match = mime_magic->match_list; match; match = match->next)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
for (matchlet = match->matchlet; matchlet; matchlet = matchlet->next)
|
||||
{
|
||||
int extent;
|
||||
|
||||
extent = matchlet->value_length + matchlet->offset + matchlet->range_length;
|
||||
if (max_extent < extent)
|
||||
max_extent = extent;
|
||||
}
|
||||
}
|
||||
|
||||
mime_magic->max_extent = max_extent;
|
||||
}
|
||||
|
||||
static XdgMimeMagicMatchlet *
|
||||
_xdg_mime_magic_matchlet_mirror (XdgMimeMagicMatchlet *matchlets)
|
||||
{
|
||||
XdgMimeMagicMatchlet *new_list;
|
||||
XdgMimeMagicMatchlet *tmp;
|
||||
|
||||
if ((matchlets == NULL) || (matchlets->next == NULL))
|
||||
return matchlets;
|
||||
|
||||
new_list = NULL;
|
||||
tmp = matchlets;
|
||||
while (tmp != NULL)
|
||||
{
|
||||
XdgMimeMagicMatchlet *matchlet;
|
||||
|
||||
matchlet = tmp;
|
||||
tmp = tmp->next;
|
||||
matchlet->next = new_list;
|
||||
new_list = matchlet;
|
||||
}
|
||||
|
||||
return new_list;
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
_xdg_mime_magic_read_magic_file (XdgMimeMagic *mime_magic,
|
||||
FILE *magic_file)
|
||||
{
|
||||
XdgMimeMagicState state;
|
||||
XdgMimeMagicMatch *match = NULL; /* Quiet compiler */
|
||||
|
||||
state = XDG_MIME_MAGIC_SECTION;
|
||||
|
||||
while (state != XDG_MIME_MAGIC_EOF)
|
||||
{
|
||||
switch (state)
|
||||
{
|
||||
case XDG_MIME_MAGIC_SECTION:
|
||||
match = _xdg_mime_magic_match_new ();
|
||||
state = _xdg_mime_magic_parse_header (magic_file, match);
|
||||
if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
|
||||
_xdg_mime_magic_match_free (match);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_MAGIC:
|
||||
state = _xdg_mime_magic_parse_magic_line (magic_file, match);
|
||||
if (state == XDG_MIME_MAGIC_SECTION ||
|
||||
(state == XDG_MIME_MAGIC_EOF && match->mime_type))
|
||||
{
|
||||
match->matchlet = _xdg_mime_magic_matchlet_mirror (match->matchlet);
|
||||
_xdg_mime_magic_insert_match (mime_magic, match);
|
||||
}
|
||||
else if (state == XDG_MIME_MAGIC_EOF || state == XDG_MIME_MAGIC_ERROR)
|
||||
_xdg_mime_magic_match_free (match);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_ERROR:
|
||||
state = _xdg_mime_magic_parse_error (magic_file);
|
||||
break;
|
||||
case XDG_MIME_MAGIC_EOF:
|
||||
default:
|
||||
/* Make the compiler happy */
|
||||
assert (0);
|
||||
}
|
||||
}
|
||||
_xdg_mime_update_mime_magic_extents (mime_magic);
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *magic_file;
|
||||
char header[12];
|
||||
|
||||
magic_file = fopen (file_name, "r");
|
||||
|
||||
if (magic_file == NULL)
|
||||
return;
|
||||
|
||||
if (fread (header, 1, 12, magic_file) == 12)
|
||||
{
|
||||
if (memcmp ("MIME-Magic\0\n", header, 12) == 0)
|
||||
_xdg_mime_magic_read_magic_file (mime_magic, magic_file);
|
||||
}
|
||||
|
||||
fclose (magic_file);
|
||||
}
|
||||
57
xdgmime-source/src/xdgmimemagic.h
Normal file
57
xdgmime-source/src/xdgmimemagic.h
Normal file
@ -0,0 +1,57 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimemagic.h: Private file. Datastructure for storing the magic files.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2003 Red Hat, Inc.
|
||||
* Copyright (C) 2003 Jonathan Blandford <jrb@alum.mit.edu>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_MAGIC_H__
|
||||
#define __XDG_MIME_MAGIC_H__
|
||||
|
||||
#include <unistd.h>
|
||||
#include "xdgmime.h"
|
||||
typedef struct XdgMimeMagic XdgMimeMagic;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_glob_read_from_file XDG_RESERVED_ENTRY(glob_read_from_file)
|
||||
#define _xdg_mime_magic_new XDG_RESERVED_ENTRY(magic_new)
|
||||
#define _xdg_mime_magic_read_from_file XDG_RESERVED_ENTRY(magic_read_from_file)
|
||||
#define _xdg_mime_magic_free XDG_RESERVED_ENTRY(magic_free)
|
||||
#define _xdg_mime_magic_get_buffer_extents XDG_RESERVED_ENTRY(magic_get_buffer_extents)
|
||||
#define _xdg_mime_magic_lookup_data XDG_RESERVED_ENTRY(magic_lookup_data)
|
||||
#endif
|
||||
|
||||
|
||||
XdgMimeMagic *_xdg_mime_magic_new (void);
|
||||
void _xdg_mime_magic_read_from_file (XdgMimeMagic *mime_magic,
|
||||
const char *file_name);
|
||||
void _xdg_mime_magic_free (XdgMimeMagic *mime_magic);
|
||||
int _xdg_mime_magic_get_buffer_extents (XdgMimeMagic *mime_magic);
|
||||
const char *_xdg_mime_magic_lookup_data (XdgMimeMagic *mime_magic,
|
||||
const void *data,
|
||||
size_t len,
|
||||
int *result_prio,
|
||||
const char *mime_types[],
|
||||
int n_mime_types);
|
||||
|
||||
#endif /* __XDG_MIME_MAGIC_H__ */
|
||||
219
xdgmime-source/src/xdgmimeparent.c
Normal file
219
xdgmime-source/src/xdgmimeparent.c
Normal file
@ -0,0 +1,219 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimealias.c: Private file. Datastructure for storing the hierarchy.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 2004 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "xdgmimeparent.h"
|
||||
#include "xdgmimeint.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (!FALSE)
|
||||
#endif
|
||||
|
||||
typedef struct XdgMimeParents XdgMimeParents;
|
||||
|
||||
struct XdgMimeParents
|
||||
{
|
||||
char *mime;
|
||||
char **parents;
|
||||
int n_parents;
|
||||
};
|
||||
|
||||
struct XdgParentList
|
||||
{
|
||||
struct XdgMimeParents *parents;
|
||||
int n_mimes;
|
||||
};
|
||||
|
||||
XdgParentList *
|
||||
_xdg_mime_parent_list_new (void)
|
||||
{
|
||||
XdgParentList *list;
|
||||
|
||||
list = malloc (sizeof (XdgParentList));
|
||||
|
||||
list->parents = NULL;
|
||||
list->n_mimes = 0;
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_parent_list_free (XdgParentList *list)
|
||||
{
|
||||
int i;
|
||||
char **p;
|
||||
|
||||
if (list->parents)
|
||||
{
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
for (p = list->parents[i].parents; *p; p++)
|
||||
free (*p);
|
||||
|
||||
free (list->parents[i].parents);
|
||||
free (list->parents[i].mime);
|
||||
}
|
||||
free (list->parents);
|
||||
}
|
||||
free (list);
|
||||
}
|
||||
|
||||
static int
|
||||
parent_entry_cmp (const void *v1, const void *v2)
|
||||
{
|
||||
return strcmp (((XdgMimeParents *)v1)->mime, ((XdgMimeParents *)v2)->mime);
|
||||
}
|
||||
|
||||
const char **
|
||||
_xdg_mime_parent_list_lookup (XdgParentList *list,
|
||||
const char *mime)
|
||||
{
|
||||
XdgMimeParents *entry;
|
||||
XdgMimeParents key;
|
||||
|
||||
if (list->n_mimes > 0)
|
||||
{
|
||||
key.mime = (char *)mime;
|
||||
key.parents = NULL;
|
||||
|
||||
entry = bsearch (&key, list->parents, list->n_mimes,
|
||||
sizeof (XdgMimeParents), &parent_entry_cmp);
|
||||
if (entry)
|
||||
return (const char **)entry->parents;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
_xdg_mime_parent_read_from_file (XdgParentList *list,
|
||||
const char *file_name)
|
||||
{
|
||||
FILE *file;
|
||||
char line[255];
|
||||
int i, alloc;
|
||||
XdgMimeParents *entry;
|
||||
|
||||
file = fopen (file_name, "r");
|
||||
|
||||
if (file == NULL)
|
||||
return;
|
||||
|
||||
/* FIXME: Not UTF-8 safe. Doesn't work if lines are greater than 255 chars.
|
||||
* Blah */
|
||||
alloc = list->n_mimes + 16;
|
||||
list->parents = realloc (list->parents, alloc * sizeof (XdgMimeParents));
|
||||
while (fgets (line, 255, file) != NULL)
|
||||
{
|
||||
char *sep;
|
||||
if (line[0] == '#')
|
||||
continue;
|
||||
|
||||
sep = strchr (line, ' ');
|
||||
if (sep == NULL)
|
||||
continue;
|
||||
*(sep++) = '\000';
|
||||
sep[strlen (sep) -1] = '\000';
|
||||
entry = NULL;
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
if (strcmp (list->parents[i].mime, line) == 0)
|
||||
{
|
||||
entry = &(list->parents[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!entry)
|
||||
{
|
||||
if (list->n_mimes == alloc)
|
||||
{
|
||||
alloc <<= 1;
|
||||
list->parents = realloc (list->parents,
|
||||
alloc * sizeof (XdgMimeParents));
|
||||
}
|
||||
list->parents[list->n_mimes].mime = strdup (line);
|
||||
list->parents[list->n_mimes].parents = NULL;
|
||||
entry = &(list->parents[list->n_mimes]);
|
||||
list->n_mimes++;
|
||||
}
|
||||
|
||||
if (!entry->parents)
|
||||
{
|
||||
entry->n_parents = 1;
|
||||
entry->parents = malloc ((entry->n_parents + 1) * sizeof (char *));
|
||||
}
|
||||
else
|
||||
{
|
||||
entry->n_parents += 1;
|
||||
entry->parents = realloc (entry->parents,
|
||||
(entry->n_parents + 2) * sizeof (char *));
|
||||
}
|
||||
entry->parents[entry->n_parents - 1] = strdup (sep);
|
||||
entry->parents[entry->n_parents] = NULL;
|
||||
}
|
||||
|
||||
list->parents = realloc (list->parents,
|
||||
list->n_mimes * sizeof (XdgMimeParents));
|
||||
|
||||
fclose (file);
|
||||
|
||||
if (list->n_mimes > 1)
|
||||
qsort (list->parents, list->n_mimes,
|
||||
sizeof (XdgMimeParents), &parent_entry_cmp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_xdg_mime_parent_list_dump (XdgParentList *list)
|
||||
{
|
||||
int i;
|
||||
char **p;
|
||||
|
||||
if (list->parents)
|
||||
{
|
||||
for (i = 0; i < list->n_mimes; i++)
|
||||
{
|
||||
for (p = list->parents[i].parents; *p; p++)
|
||||
printf ("%s %s\n", list->parents[i].mime, *p);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
51
xdgmime-source/src/xdgmimeparent.h
Normal file
51
xdgmime-source/src/xdgmimeparent.h
Normal file
@ -0,0 +1,51 @@
|
||||
/* -*- mode: C; c-file-style: "gnu" -*- */
|
||||
/* xdgmimeparent.h: Private file. Datastructure for storing the hierarchy.
|
||||
*
|
||||
* More info can be found at http://www.freedesktop.org/standards/
|
||||
*
|
||||
* Copyright (C) 2004 Red Hat, Inc.
|
||||
* Copyright (C) 200 Matthias Clasen <mclasen@redhat.com>
|
||||
*
|
||||
* Licensed under the Academic Free License version 2.0
|
||||
* Or under the following terms:
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XDG_MIME_PARENT_H__
|
||||
#define __XDG_MIME_PARENT_H__
|
||||
|
||||
#include "xdgmime.h"
|
||||
|
||||
typedef struct XdgParentList XdgParentList;
|
||||
|
||||
#ifdef XDG_PREFIX
|
||||
#define _xdg_mime_parent_read_from_file XDG_RESERVED_ENTRY(parent_read_from_file)
|
||||
#define _xdg_mime_parent_list_new XDG_RESERVED_ENTRY(parent_list_new)
|
||||
#define _xdg_mime_parent_list_free XDG_RESERVED_ENTRY(parent_list_free)
|
||||
#define _xdg_mime_parent_list_lookup XDG_RESERVED_ENTRY(parent_list_lookup)
|
||||
#define _xdg_mime_parent_list_dump XDG_RESERVED_ENTRY(parent_list_dump)
|
||||
#endif
|
||||
|
||||
void _xdg_mime_parent_read_from_file (XdgParentList *list,
|
||||
const char *file_name);
|
||||
XdgParentList *_xdg_mime_parent_list_new (void);
|
||||
void _xdg_mime_parent_list_free (XdgParentList *list);
|
||||
const char **_xdg_mime_parent_list_lookup (XdgParentList *list,
|
||||
const char *mime);
|
||||
void _xdg_mime_parent_list_dump (XdgParentList *list);
|
||||
|
||||
#endif /* __XDG_MIME_PARENT_H__ */
|
||||
Loading…
Reference in New Issue
Block a user