* add xdgmime from freedesktop.org
authorWilfried Göesgens <willi@citadel.org>
Sat, 9 Feb 2008 14:59:37 +0000 (14:59 +0000)
committerWilfried Göesgens <willi@citadel.org>
Sat, 9 Feb 2008 14:59:37 +0000 (14:59 +0000)
* tiny wrapper, which bears our own functionality as comment (just in case)

25 files changed:
libcitadel/Makefile.in
libcitadel/configure.in
libcitadel/debian/control
libcitadel/lib/libcitadel.h
libcitadel/lib/mime_parser.c
libcitadel/lib/xdgmime/.cvsignore [new file with mode: 0644]
libcitadel/lib/xdgmime/ChangeLog [new file with mode: 0644]
libcitadel/lib/xdgmime/Makefile [new file with mode: 0644]
libcitadel/lib/xdgmime/README [new file with mode: 0644]
libcitadel/lib/xdgmime/test-mime-data.c [new file with mode: 0644]
libcitadel/lib/xdgmime/test-mime.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmime.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmime.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimealias.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimealias.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimecache.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimecache.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeglob.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeglob.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeint.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeint.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimemagic.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimemagic.h [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeparent.c [new file with mode: 0644]
libcitadel/lib/xdgmime/xdgmimeparent.h [new file with mode: 0644]

index 72f3174..4f9e76c 100755 (executable)
@@ -101,7 +101,20 @@ LINK_LIB = $(LIBTOOL) $(LTFLAGS) --mode=link $(COMPILE) -no-undefined $(VSNFLAG)
 LINK_EXE = $(LIBTOOL) $(LTFLAGS) --mode=link $(COMPILE) $(LDFLAGS) -o $@
 LINK_CXX_EXE = $(LIBTOOL) $(LTFLAGS) --mode=link $(CXXCOMPILE) $(LDFLAGS) -o $@
 
-LIB_OBJS = lib/libcitadel.lo lib/mime_parser.lo lib/tools.lo lib/vcard.lo lib/hash.lo lib/lookup3.lo
+LIB_OBJS = lib/libcitadel.lo \
+       lib/mime_parser.lo \
+       lib/tools.lo \
+       lib/vcard.lo \
+       lib/hash.lo \
+       lib/lookup3.lo \
+       lib/xdgmime/xdgmime.lo \
+       lib/xdgmime/xdgmimeglob.lo \
+       lib/xdgmime/xdgmimeint.lo \
+       lib/xdgmime/xdgmimemagic.lo \
+       lib/xdgmime/xdgmimealias.lo \
+       lib/xdgmime/xdgmimeparent.lo \
+       lib/xdgmime/xdgmimecache.lo
+
 $(LIBRARY): $(LIB_OBJS)
        $(LINK_LIB) $(LIB_OBJS)
 
@@ -111,6 +124,13 @@ lib/tools.lo: lib/tools.c lib/libcitadel.h
 lib/vcard.lo: lib/vcard.c lib/libcitadel.h
 lib/lookup3.lo: lib/lookup3.c lib/libcitadel.h
 lib/hash.lo: lib/hash.c lib/libcitadel.h
+lib/xdgmime/xdgmime.lo: lib/xdgmime/xdgmime.c 
+lib/xdgmime/xdgmimeglob.lo:  lib/xdgmime/xdgmimeglob.c 
+lib/xdgmime/xdgmimeint.lo:  lib/xdgmime/xdgmimeint.c 
+lib/xdgmime/xdgmimemagic.lo:  lib/xdgmime/xdgmimemagic.c 
+lib/xdgmime/xdgmimealias.lo:  lib/xdgmime/xdgmimealias.c 
+lib/xdgmime/xdgmimeparent.lo:  lib/xdgmime/xdgmimeparent.c 
+lib/xdgmime/xdgmimecache.lo: lib/xdgmime/xdgmimecache.c
 
 .SUFFIXES: .c .cpp .lo .o
 
@@ -125,3 +145,15 @@ lib/hash.lo: lib/hash.c lib/libcitadel.h
        clean distclean extraclean maintainer-clean \
        dist distdir \
        install uninstall
+
+
+
+
+#
+#xdgmime.o 
+#xdgmimeglob.o 
+#xdgmimeint.o 
+#xdgmimemagic.o 
+#xdgmimealias.o 
+#xdgmimeparent.o 
+#xdgmimecache.o
index 532b35b..7b6a609 100755 (executable)
@@ -57,6 +57,9 @@ fi
 dnl Checks for header files.
 AC_HEADER_STDC
 
+AC_CHECK_HEADER(sys/mman.h, AC_DEFINE_UNQUOTED(HAVE_MMAP, [whether whe have sys/mmap.h]))
+
+
 dnl Checks for typedefs, structures, and compiler characteristics.
 
 AC_C_CONST
index 7bd9801..b4e5be1 100644 (file)
@@ -9,7 +9,7 @@ Homepage: http://citadel.org
 
 Package: libcitadel1
 Architecture: any
-Depends: ${shlibs:Depends}
+Depends: ${shlibs:Depends}, shared-mime-info
 Description: Citadel toolbox
  This library contains the commonly used routines for the citadel suite.
 
index edd37fb..3d1e646 100644 (file)
@@ -169,6 +169,7 @@ void the_mime_parser(char *partnum,
 );
 
 const char *GuessMimeType(char *data, size_t dlen);
+const char* GuessMimeByFilename(const char *what, size_t len);
 
 
 
index a775327..0da90ae 100644 (file)
@@ -18,6 +18,7 @@
 #include <sys/stat.h>
 #include <errno.h>
 
+#include "xdgmime/xdgmime.h"
 #include "libcitadel.h"
 
 void extract_key(char *target, char *source, char *key)
@@ -680,6 +681,8 @@ MimeGuess MyMimes [] = {
 
 const char *GuessMimeType(char *data, size_t dlen)
 {
+       return (xdg_mime_get_mime_type_for_data(data, dlen));
+/*
        int MimeIndex = 0;
 
        while (MyMimes[MimeIndex].PatternLen != 0)
@@ -695,5 +698,43 @@ const char *GuessMimeType(char *data, size_t dlen)
                MimeIndex ++;
        }
        return MyMimes[MimeIndex].MimeString;
+*/
+}
+
 
+const char* GuessMimeByFilename(const char *what, size_t len)
+{
+       return xdg_mime_get_mime_type_from_file_name(what);
+/*
+       if (!strncasecmp(&what[len - 4], ".gif", 4))
+               return "image/gif";
+       else if (!strncasecmp(&what[len - 3], ".js", 3))
+               return  "text/javascript";
+       else if (!strncasecmp(&what[len - 4], ".txt", 4))
+               return "text/plain";
+       else if (!strncasecmp(&what[len - 4], ".css", 4))
+               return "text/css";
+       else if (!strncasecmp(&what[len - 4], ".jpg", 4))
+               return "image/jpeg";
+       else if (!strncasecmp(&what[len - 4], ".png", 4))
+               return "image/png";
+       else if (!strncasecmp(&what[len - 4], ".ico", 4))
+               return "image/x-icon";
+       else if (!strncasecmp(&what[len - 5], ".html", 5))
+               return "text/html";
+       else if (!strncasecmp(&what[len - 4], ".htm", 4))
+               return "text/html";
+       else if (!strncasecmp(&what[len - 4], ".wml", 4))
+               return "text/vnd.wap.wml";
+       else if (!strncasecmp(&what[len - 5], ".wmls", 5))
+               return "text/vnd.wap.wmlscript";
+       else if (!strncasecmp(&what[len - 5], ".wmlc", 5))
+               return "application/vnd.wap.wmlc";
+       else if (!strncasecmp(&what[len - 6], ".wmlsc", 6))
+               return "application/vnd.wap.wmlscriptc";
+       else if (!strncasecmp(&what[len - 5], ".wbmp", 5))
+               return "image/vnd.wap.wbmp";
+       else
+               return "application/octet-stream";
+*/
 }
diff --git a/libcitadel/lib/xdgmime/.cvsignore b/libcitadel/lib/xdgmime/.cvsignore
new file mode 100644 (file)
index 0000000..38ea779
--- /dev/null
@@ -0,0 +1,3 @@
+test-mime
+test-mime-data
+*.o
diff --git a/libcitadel/lib/xdgmime/ChangeLog b/libcitadel/lib/xdgmime/ChangeLog
new file mode 100644 (file)
index 0000000..fe8eca5
--- /dev/null
@@ -0,0 +1,462 @@
+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 inheritence 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.
+
diff --git a/libcitadel/lib/xdgmime/Makefile b/libcitadel/lib/xdgmime/Makefile
new file mode 100644 (file)
index 0000000..636f07c
--- /dev/null
@@ -0,0 +1,12 @@
+
+CFLAGS=-Wall -Wmissing-prototypes  -Wno-sign-compare -g -DXDG_PREFIX=xdg_test -DHAVE_MMAP
+
+all: test-mime test-mime-data
+
+test-mime: xdgmime.o xdgmimeglob.o xdgmimeint.o xdgmimemagic.o xdgmimealias.o xdgmimeparent.o xdgmimecache.o
+
+test-mime-data: xdgmime.o xdgmimeglob.o xdgmimeint.o xdgmimemagic.o xdgmimealias.o xdgmimeparent.o xdgmimecache.o
+
+clean:
+       rm -f *~ *.o test-mime
+
diff --git a/libcitadel/lib/xdgmime/README b/libcitadel/lib/xdgmime/README
new file mode 100644 (file)
index 0000000..e7f3f68
--- /dev/null
@@ -0,0 +1,8 @@
+This module is a simple module that parses the proposed MIME spec listed
+at http://freedesktop.org/.  It is currently targetted 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.
diff --git a/libcitadel/lib/xdgmime/test-mime-data.c b/libcitadel/lib/xdgmime/test-mime-data.c
new file mode 100644 (file)
index 0000000..d2807a3
--- /dev/null
@@ -0,0 +1,327 @@
+/* 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 (strcmp (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 > 1)
+         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;
+  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++;
+
+      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);
+  
+  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");
+
+      return 1;
+    }
+
+  return 0;
+}
diff --git a/libcitadel/lib/xdgmime/test-mime.c b/libcitadel/lib/xdgmime/test-mime.c
new file mode 100644 (file)
index 0000000..7cff59b
--- /dev/null
@@ -0,0 +1,142 @@
+/* 
+ * 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")));
+    }
+}
+
+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);
+    }
+}
+
+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);
+    }
+}
+
+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", 0);
+}
+
+int
+main (int argc, char *argv[])
+{
+  const char *result;
+  const char *file_name;
+  int i;
+
+  test_glob_type ();
+  test_aliasing ();
+  test_subclassing ();
+
+  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;
+}
+     
diff --git a/libcitadel/lib/xdgmime/xdgmime.c b/libcitadel/lib/xdgmime/xdgmime.c
new file mode 100644 (file)
index 0000000..872b929
--- /dev/null
@@ -0,0 +1,868 @@
+/* -*- 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 "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;
+
+XdgMimeCache **_xdg_mime_caches = NULL;
+static int n_caches = 0;
+
+const char xdg_mime_type_unknown[] = "application/octet-stream";
+
+
+enum
+{
+  XDG_CHECKED_UNCHECKED,
+  XDG_CHECKED_VALID,
+  XDG_CHECKED_INVALID
+};
+
+struct XdgDirTimeList
+{
+  time_t mtime;
+  char *directory_name;
+  int checked;
+  XdgDirTimeList *next;
+  XdgMimeCache *cache;
+};
+
+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 XdgDirTimeList *
+xdg_dir_time_list_new (void)
+{
+  XdgDirTimeList *retval;
+
+  retval = calloc (1, sizeof (XdgDirTimeList));
+  retval->checked = XDG_CHECKED_UNCHECKED;
+
+  return retval;
+}
+
+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)
+{
+  char *file_name;
+  struct stat st;
+  XdgDirTimeList *list;
+
+  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)
+       {
+         list = xdg_dir_time_list_new ();
+         list->directory_name = file_name;
+         list->mtime = st.st_mtime;
+         list->next = dir_time_list;
+         list->cache = cache;
+         dir_time_list = list;
+
+         _xdg_mime_caches = realloc (_xdg_mime_caches, sizeof (XdgMimeCache *) * (n_caches + 2));
+         _xdg_mime_caches[n_caches] = cache;
+          _xdg_mime_caches[n_caches + 1] = NULL;
+         n_caches++;
+
+         return FALSE;
+       }
+    }
+  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);
+
+      list = xdg_dir_time_list_new ();
+      list->directory_name = file_name;
+      list->mtime = st.st_mtime;
+      list->next = dir_time_list;
+      dir_time_list = list;
+    }
+  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);
+
+      list = xdg_dir_time_list_new ();
+      list->directory_name = file_name;
+      list->mtime = st.st_mtime;
+      list->next = dir_time_list;
+      dir_time_list = list;
+    }
+  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);
+
+  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;
+    }
+}
+
+static XdgMimeCache *
+xdg_lookup_cache_for_file (const char *file_path)
+{
+  XdgDirTimeList *list;
+
+  for (list = dir_time_list; list; list = list->next)
+      if (! strcmp (list->directory_name, file_path))
+        return list->cache;
+
+  return NULL;
+}
+
+/* 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)
+{
+  struct stat st;
+
+  /* If the file exists */
+  if (stat (file_path, &st) == 0)
+    {
+      XdgDirTimeList *list;
+
+      for (list = dir_time_list; list; list = list->next)
+       {
+         if (! strcmp (list->directory_name, file_path) &&
+             st.st_mtime == list->mtime)
+           {
+             if (list->checked == XDG_CHECKED_UNCHECKED)
+               list->checked = XDG_CHECKED_VALID;
+             else if (list->checked == XDG_CHECKED_VALID)
+               list->checked = XDG_CHECKED_INVALID;
+
+             return (list->checked != XDG_CHECKED_VALID);
+           }
+       }
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static int
+xdg_check_dir (const char *directory,
+              int        *invalid_dir_list)
+{
+  int invalid, has_cache;
+  char *file_name;
+
+  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);
+  has_cache = xdg_lookup_cache_for_file (file_name) != NULL;
+  free (file_name);
+
+  if (has_cache)
+    {
+      if (invalid)
+       {
+         *invalid_dir_list = TRUE;
+         return TRUE;
+       }
+
+      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);
+  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);
+  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 ((XdgDirectoryFunc) 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 ();
+
+      xdg_run_command_on_dirs ((XdgDirectoryFunc) xdg_mime_init_from_directory,
+                              NULL);
+
+      need_reread = FALSE;
+    }
+}
+
+const char *
+xdg_mime_get_mime_type_for_data (const void *data,
+                                size_t      len)
+{
+  const char *mime_type;
+
+  xdg_mime_init ();
+
+  if (_xdg_mime_caches)
+    return _xdg_mime_cache_get_mime_type_for_data (data, len);
+
+  mime_type = _xdg_mime_magic_lookup_data (global_magic, data, len, NULL, 0);
+
+  if (mime_type)
+    return mime_type;
+
+  return XDG_MIME_TYPE_UNKNOWN;
+}
+
+const char *
+xdg_mime_get_mime_type_for_file (const char  *file_name,
+                                 struct stat *statbuf)
+{
+  const char *mime_type;
+  /* Used to detect whether multiple MIME types match file_name */
+  const char *mime_types[2];
+  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 (_xdg_mime_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, 2);
+
+  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,
+                                          mime_types, n);
+
+  free (data);
+  fclose (file);
+
+  if (mime_type)
+    return mime_type;
+
+  return XDG_MIME_TYPE_UNKNOWN;
+}
+
+const char *
+xdg_mime_get_mime_type_from_file_name (const char *file_name)
+{
+  const char *mime_types[2];
+
+  xdg_mime_init ();
+
+  if (_xdg_mime_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_types, 2) == 1)
+    return mime_types[0];
+  else
+    return XDG_MIME_TYPE_UNKNOWN;
+}
+
+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 (_xdg_mime_caches)
+    {
+      int i;
+      for (i = 0; i < n_caches; i++)
+        _xdg_mime_cache_unref (_xdg_mime_caches[i]);
+      free (_xdg_mime_caches);
+      _xdg_mime_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 (_xdg_mime_caches)
+    return _xdg_mime_cache_get_max_buffer_extents ();
+
+  return _xdg_mime_magic_get_buffer_extents (global_magic);
+}
+
+static const char *
+_xdg_mime_unalias_mime_type (const char *mime_type)
+{
+  const char *lookup;
+
+  if (_xdg_mime_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;
+
+  xdg_mime_init ();
+
+  sep = strchr (mime_a, '/');
+  
+  if (sep && strncmp (mime_a, mime_b, sep - mime_a + 1) == 0)
+    return 1;
+
+  return 0;
+}
+
+int
+xdg_mime_media_type_equal (const char *mime_a,
+                          const char *mime_b)
+{
+  xdg_mime_init ();
+
+  return _xdg_mime_media_type_equal (mime_a, mime_b);
+}
+
+#if 0
+static int
+xdg_mime_is_super_type (const char *mime)
+{
+  int length;
+  const char *type;
+
+  length = strlen (mime);
+  type = &(mime[length - 2]);
+
+  if (strcmp (type, "/*") == 0)
+    return 1;
+
+  return 0;
+}
+#endif
+
+int
+_xdg_mime_mime_type_subclass (const char *mime,
+                             const char *base)
+{
+  const char *umime, *ubase;
+  const char **parents;
+
+  if (_xdg_mime_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 0  
+  /* 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)
+    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 (_xdg_mime_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)
+{
+  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);
+}
+
+
+/* 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;
+       }
+    }
+}
diff --git a/libcitadel/lib/xdgmime/xdgmime.h b/libcitadel/lib/xdgmime/xdgmime.h
new file mode 100644 (file)
index 0000000..82b5585
--- /dev/null
@@ -0,0 +1,119 @@
+/* -*- 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(mime_get_mime_type_for_data)
+#define xdg_mime_get_mime_type_for_file       XDG_ENTRY(mime_get_mime_type_for_file)
+#define xdg_mime_get_mime_type_from_file_name XDG_ENTRY(mime_get_mime_type_from_file_name)
+#define xdg_mime_is_valid_mime_type           XDG_ENTRY(mime_is_valid_mime_type)
+#define xdg_mime_mime_type_equal              XDG_ENTRY(mime_mime_type_equal)
+#define xdg_mime_media_type_equal             XDG_ENTRY(mime_media_type_equal)
+#define xdg_mime_mime_type_subclass           XDG_ENTRY(mime_mime_type_subclass)
+#define xdg_mime_get_mime_parents             XDG_ENTRY(mime_get_mime_parents)
+#define xdg_mime_list_mime_parents            XDG_ENTRY(mime_list_mime_parents)
+#define xdg_mime_unalias_mime_type            XDG_ENTRY(mime_unalias_mime_type)
+#define xdg_mime_get_max_buffer_extents       XDG_ENTRY(mime_get_max_buffer_extents)
+#define xdg_mime_shutdown                     XDG_ENTRY(mime_shutdown)
+#define xdg_mime_dump                         XDG_ENTRY(mime_dump)
+#define xdg_mime_register_reload_callback     XDG_ENTRY(mime_register_reload_callback)
+#define xdg_mime_remove_callback              XDG_ENTRY(mime_remove_callback)
+#define xdg_mime_type_unknown                 XDG_ENTRY(mime_type_unknown)
+
+#define _xdg_mime_mime_type_equal             XDG_RESERVED_ENTRY(mime_mime_type_equal)
+#define _xdg_mime_media_type_equal            XDG_RESERVED_ENTRY(mime_media_type_equal)
+#define _xdg_mime_mime_type_subclass          XDG_RESERVED_ENTRY(mime_mime_type_subclass)
+#endif
+
+extern const char xdg_mime_type_unknown[];
+#define XDG_MIME_TYPE_UNKNOWN xdg_mime_type_unknown
+
+const char  *xdg_mime_get_mime_type_for_data       (const void *data,
+                                                   size_t      len);
+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_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);
+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_media_type_equal            (const char *mime_a,
+                                                   const char *mime_b);
+int          _xdg_mime_mime_type_subclass          (const char *mime,
+                                                   const char *base);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XDG_MIME_H__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimealias.c b/libcitadel/lib/xdgmime/xdgmimealias.c
new file mode 100644 (file)
index 0000000..07d89eb
--- /dev/null
@@ -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);
+       }
+    }
+}
+
+
diff --git a/libcitadel/lib/xdgmime/xdgmimealias.h b/libcitadel/lib/xdgmime/xdgmimealias.h
new file mode 100644 (file)
index 0000000..b308fed
--- /dev/null
@@ -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(mime_alias_read_from_file)
+#define _xdg_mime_alias_list_new              XDG_RESERVED_ENTRY(mime_alias_list_new)
+#define _xdg_mime_alias_list_free             XDG_RESERVED_ENTRY(mime_alias_list_free)
+#define _xdg_mime_alias_list_lookup           XDG_RESERVED_ENTRY(mime_alias_list_lookup)
+#define _xdg_mime_alias_list_dump             XDG_RESERVED_ENTRY(mime_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__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimecache.c b/libcitadel/lib/xdgmime/xdgmimecache.c
new file mode 100644 (file)
index 0000000..d5eae93
--- /dev/null
@@ -0,0 +1,898 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* xdgmimealias.c: Private file.  mmappable caches for mime data
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <fnmatch.h>
+#include <assert.h>
+
+#include <netinet/in.h> /* for ntohl/ntohs */
+
+#ifdef HAVE_MMAP
+#include <sys/mman.h>
+#else
+#warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used.
+#endif
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "xdgmimecache.h"
+#include "xdgmimeint.h"
+
+#ifndef MAX
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef        FALSE
+#define        FALSE   (0)
+#endif
+
+#ifndef        TRUE
+#define        TRUE    (!FALSE)
+#endif
+
+#ifndef _O_BINARY
+#define _O_BINARY 0
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+
+#define MAJOR_VERSION 1
+#define MINOR_VERSION 0
+
+struct _XdgMimeCache
+{
+  int ref_count;
+
+  size_t  size;
+  char   *buffer;
+};
+
+#define GET_UINT16(cache,offset) (ntohs(*(xdg_uint16_t*)((cache) + (offset))))
+#define GET_UINT32(cache,offset) (ntohl(*(xdg_uint32_t*)((cache) + (offset))))
+
+XdgMimeCache *
+_xdg_mime_cache_ref (XdgMimeCache *cache)
+{
+  cache->ref_count++;
+  return cache;
+}
+
+void
+_xdg_mime_cache_unref (XdgMimeCache *cache)
+{
+  cache->ref_count--;
+
+  if (cache->ref_count == 0)
+    {
+#ifdef HAVE_MMAP
+      munmap (cache->buffer, cache->size);
+#endif
+      free (cache);
+    }
+}
+
+XdgMimeCache *
+_xdg_mime_cache_new_from_file (const char *file_name)
+{
+  XdgMimeCache *cache = NULL;
+
+#ifdef HAVE_MMAP
+  int fd = -1;
+  struct stat st;
+  char *buffer = NULL;
+
+  /* Open the file and map it into memory */
+  fd = open (file_name, O_RDONLY|_O_BINARY, 0);
+
+  if (fd < 0)
+    return NULL;
+  
+  if (fstat (fd, &st) < 0 || st.st_size < 4)
+    goto done;
+
+  buffer = (char *) mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+
+  if (buffer == MAP_FAILED)
+    goto done;
+
+  /* Verify version */
+  if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
+      GET_UINT16 (buffer, 2) != MINOR_VERSION)
+    {
+      munmap (buffer, st.st_size);
+
+      goto done;
+    }
+  
+  cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
+  cache->ref_count = 1;
+  cache->buffer = buffer;
+  cache->size = st.st_size;
+
+ done:
+  if (fd != -1)
+    close (fd);
+
+#endif  /* HAVE_MMAP */
+
+  return cache;
+}
+
+static int
+cache_magic_matchlet_compare_to_data (XdgMimeCache *cache, 
+                                     xdg_uint32_t  offset,
+                                     const void   *data,
+                                     size_t        len)
+{
+  xdg_uint32_t range_start = GET_UINT32 (cache->buffer, offset);
+  xdg_uint32_t range_length = GET_UINT32 (cache->buffer, offset + 4);
+  xdg_uint32_t data_length = GET_UINT32 (cache->buffer, offset + 12);
+  xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
+  xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
+  
+  int i, j;
+
+  for (i = range_start; i <= range_start + range_length; i++)
+    {
+      int valid_matchlet = TRUE;
+      
+      if (i + data_length > len)
+       return FALSE;
+
+      if (mask_offset)
+       {
+         for (j = 0; j < data_length; j++)
+           {
+             if ((((unsigned char *)cache->buffer)[data_offset + j] & ((unsigned char *)cache->buffer)[mask_offset + j]) !=
+                 ((((unsigned char *) data)[j + i]) & ((unsigned char *)cache->buffer)[mask_offset + j]))
+               {
+                 valid_matchlet = FALSE;
+                 break;
+               }
+           }
+       }
+      else
+       {
+         for (j = 0; j < data_length; j++)
+           {
+             if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
+               {
+                 valid_matchlet = FALSE;
+                 break;
+               }
+           }
+       }
+      
+      if (valid_matchlet)
+       return TRUE;
+    }
+  
+  return FALSE;  
+}
+
+static int
+cache_magic_matchlet_compare (XdgMimeCache *cache, 
+                             xdg_uint32_t  offset,
+                             const void   *data,
+                             size_t        len)
+{
+  xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
+  xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
+
+  int i;
+  
+  if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
+    {
+      if (n_children == 0)
+       return TRUE;
+      
+      for (i = 0; i < n_children; i++)
+       {
+         if (cache_magic_matchlet_compare (cache, child_offset + 32 * i,
+                                           data, len))
+           return TRUE;
+       }
+    }
+  
+  return FALSE;  
+}
+
+static const char *
+cache_magic_compare_to_data (XdgMimeCache *cache, 
+                            xdg_uint32_t  offset,
+                            const void   *data, 
+                            size_t        len, 
+                            int          *prio)
+{
+  xdg_uint32_t priority = GET_UINT32 (cache->buffer, offset);
+  xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, offset + 4);
+  xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
+  xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
+
+  int i;
+
+  for (i = 0; i < n_matchlets; i++)
+    {
+      if (cache_magic_matchlet_compare (cache, matchlet_offset + i * 32, 
+                                       data, len))
+       {
+         *prio = priority;
+         
+         return cache->buffer + mimetype_offset;
+       }
+    }
+
+  return NULL;
+}
+
+static const char *
+cache_magic_lookup_data (XdgMimeCache *cache, 
+                        const void   *data, 
+                        size_t        len, 
+                        int          *prio,
+                        const char   *mime_types[],
+                        int           n_mime_types)
+{
+  xdg_uint32_t list_offset;
+  xdg_uint32_t n_entries;
+  xdg_uint32_t offset;
+
+  int j, n;
+
+  *prio = 0;
+
+  list_offset = GET_UINT32 (cache->buffer, 24);
+  n_entries = GET_UINT32 (cache->buffer, list_offset);
+  offset = GET_UINT32 (cache->buffer, list_offset + 8);
+  
+  for (j = 0; j < n_entries; j++)
+    {
+      const char *match;
+
+      match = cache_magic_compare_to_data (cache, offset + 16 * j, 
+                                          data, len, prio);
+      if (match)
+       return match;
+      else
+       {
+         xdg_uint32_t mimetype_offset;
+         const char *non_match;
+         
+         mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
+         non_match = cache->buffer + mimetype_offset;
+
+         for (n = 0; n < n_mime_types; n++)
+           {
+             if (mime_types[n] && 
+                 xdg_mime_mime_type_equal (mime_types[n], non_match))
+               mime_types[n] = NULL;
+           }
+       }
+    }
+
+  return NULL;
+}
+
+static const char *
+cache_alias_lookup (const char *alias)
+{
+  const char *ptr;
+  int i, min, max, mid, cmp;
+
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+      xdg_uint32_t offset;
+
+      min = 0; 
+      max = n_entries - 1;
+      while (max >= min) 
+       {
+         mid = (min + max) / 2;
+
+         offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
+         ptr = cache->buffer + offset;
+         cmp = strcmp (ptr, alias);
+         
+         if (cmp < 0)
+           min = mid + 1;
+         else if (cmp > 0)
+           max = mid - 1;
+         else
+           {
+             offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
+             return cache->buffer + offset;
+           }
+       }
+    }
+
+  return NULL;
+}
+
+static int
+cache_glob_lookup_literal (const char *file_name,
+                          const char *mime_types[],
+                          int         n_mime_types)
+{
+  const char *ptr;
+  int i, min, max, mid, cmp;
+
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+      xdg_uint32_t offset;
+
+      min = 0; 
+      max = n_entries - 1;
+      while (max >= min) 
+       {
+         mid = (min + max) / 2;
+
+         offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid);
+         ptr = cache->buffer + offset;
+         cmp = strcmp (ptr, file_name);
+         
+         if (cmp < 0)
+           min = mid + 1;
+         else if (cmp > 0)
+           max = mid - 1;
+         else
+           {
+             offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * mid + 4);
+             mime_types[0] = (const char *)(cache->buffer + offset);
+             
+             return 1;
+           }
+       }
+    }
+
+  return 0;
+}
+
+static int
+cache_glob_lookup_fnmatch (const char *file_name,
+                          const char *mime_types[],
+                          int         n_mime_types)
+{
+  const char *mime_type;
+  const char *ptr;
+
+  int i, j, n;
+
+  n = 0;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+
+      for (j = 0; j < n_entries && n < n_mime_types; j++)
+       {
+         xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
+         xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
+         ptr = cache->buffer + offset;
+         mime_type = cache->buffer + mimetype_offset;
+
+         /* FIXME: Not UTF-8 safe */
+         if (fnmatch (ptr, file_name, 0) == 0)
+           mime_types[n++] = mime_type;
+       }
+
+      if (n > 0)
+       return n;
+    }
+  
+  return 0;
+}
+
+static int
+cache_glob_node_lookup_suffix (XdgMimeCache *cache,
+                              xdg_uint32_t  n_entries,
+                              xdg_uint32_t  offset,
+                              const char   *suffix, 
+                              int           ignore_case,
+                              const char   *mime_types[],
+                              int           n_mime_types)
+{
+  xdg_unichar_t character;
+  xdg_unichar_t match_char;
+  xdg_uint32_t mimetype_offset;
+  xdg_uint32_t n_children;
+  xdg_uint32_t child_offset; 
+
+  int min, max, mid, n, i;
+
+  character = _xdg_utf8_to_ucs4 (suffix);
+  if (ignore_case)
+    character = _xdg_ucs4_to_lower (character);
+
+  min = 0;
+  max = n_entries - 1;
+  while (max >= min)
+    {
+      mid = (min + max) /  2;
+
+      match_char = GET_UINT32 (cache->buffer, offset + 16 * mid);
+
+      if (match_char < character)
+       min = mid + 1;
+      else if (match_char > character)
+       max = mid - 1;
+      else 
+       {
+         suffix = _xdg_utf8_next_char (suffix);
+         if (*suffix == '\0')
+           {
+             mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 4);
+             n = 0;
+              if (cache->buffer[mimetype_offset])
+                mime_types[n++] = cache->buffer + mimetype_offset;
+
+             n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
+             child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
+             i = 0;
+             while (n < n_mime_types && i < n_children)
+               {
+                 match_char = GET_UINT32 (cache->buffer, child_offset + 16 * i);
+                 mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * i + 4);
+                 if (match_char != 0)
+                   break;
+
+                 mime_types[n++] = cache->buffer + mimetype_offset;
+                 i++;
+               }
+
+             return n;
+           }
+         else
+           {
+             n_children = GET_UINT32 (cache->buffer, offset + 16 * mid + 8);
+             child_offset = GET_UINT32 (cache->buffer, offset + 16 * mid + 12);
+      
+             return cache_glob_node_lookup_suffix (cache, 
+                                                   n_children, child_offset,
+                                                   suffix, ignore_case,
+                                                   mime_types,
+                                                   n_mime_types);
+           }
+       }
+    }
+
+  return 0;
+}
+
+static int
+cache_glob_lookup_suffix (const char *suffix, 
+                         int         ignore_case,
+                         const char *mime_types[],
+                         int         n_mime_types)
+{
+  int i, n;
+
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+      xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
+
+      n = cache_glob_node_lookup_suffix (cache, 
+                                        n_entries, offset, 
+                                        suffix, ignore_case,
+                                        mime_types,
+                                        n_mime_types);
+      if (n > 0)
+       return n;
+    }
+
+  return 0;
+}
+
+static void
+find_stopchars (char *stopchars)
+{
+  int i, j, k, l;
+  k = 0;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+      xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
+
+      for (j = 0; j < n_entries; j++)
+       {
+         xdg_uint32_t match_char = GET_UINT32 (cache->buffer, offset);
+         
+         if (match_char < 128)
+           {
+             for (l = 0; l < k; l++)
+               if (stopchars[l] == match_char)
+                 break;
+             if (l == k)
+               {
+                 stopchars[k] = (char) match_char;
+                 k++;
+               }
+           }
+
+         offset += 16;
+       }
+    }
+
+  stopchars[k] = '\0';
+}
+
+static int
+cache_glob_lookup_file_name (const char *file_name, 
+                            const char *mime_types[],
+                            int         n_mime_types)
+{
+  const char *ptr;
+  char stopchars[128];
+  int n;
+  
+  assert (file_name != NULL);
+
+  /* First, check the literals */
+  n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types);
+  if (n > 0)
+    return n;
+
+  find_stopchars (stopchars);
+
+  /* Next, check suffixes */
+  ptr = strpbrk (file_name, stopchars);
+  while (ptr)
+    {
+      n = cache_glob_lookup_suffix (ptr, FALSE, mime_types, n_mime_types);
+      if (n > 0)
+       return n;
+      
+      n = cache_glob_lookup_suffix (ptr, TRUE, mime_types, n_mime_types);
+      if (n > 0)
+       return n;
+
+      ptr = strpbrk (ptr + 1, stopchars);
+    }
+  
+  /* Last, try fnmatch */
+  return cache_glob_lookup_fnmatch (file_name, mime_types, n_mime_types);
+}
+
+int
+_xdg_mime_cache_get_max_buffer_extents (void)
+{
+  xdg_uint32_t offset;
+  xdg_uint32_t max_extent;
+  int i;
+
+  max_extent = 0;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      offset = GET_UINT32 (cache->buffer, 24);
+      max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
+    }
+
+  return max_extent;
+}
+
+static const char *
+cache_get_mime_type_for_data (const void *data,
+                             size_t      len,
+                             const char *mime_types[],
+                             int         n_mime_types)
+{
+  const char *mime_type;
+  int i, n, priority;
+
+  priority = 0;
+  mime_type = NULL;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      int prio;
+      const char *match;
+
+      match = cache_magic_lookup_data (cache, data, len, &prio, 
+                                      mime_types, n_mime_types);
+      if (prio > priority)
+       {
+         priority = prio;
+         mime_type = match;
+       }
+    }
+
+  if (priority > 0)
+    return mime_type;
+
+  for (n = 0; n < n_mime_types; n++)
+    {
+      if (mime_types[n])
+       return mime_types[n];
+    }
+
+  return XDG_MIME_TYPE_UNKNOWN;
+}
+
+const char *
+_xdg_mime_cache_get_mime_type_for_data (const void *data,
+                                       size_t      len)
+{
+  return cache_get_mime_type_for_data (data, len, NULL, 0);
+}
+
+const char *
+_xdg_mime_cache_get_mime_type_for_file (const char  *file_name,
+                                       struct stat *statbuf)
+{
+  const char *mime_type;
+  const char *mime_types[2];
+  FILE *file;
+  unsigned char *data;
+  int max_extent;
+  int bytes_read;
+  struct stat buf;
+  const char *base_name;
+  int n;
+
+  if (file_name == NULL)
+    return NULL;
+
+  if (! _xdg_utf8_validate (file_name))
+    return NULL;
+
+  base_name = _xdg_get_base_name (file_name);
+  n = cache_glob_lookup_file_name (base_name, mime_types, 2);
+
+  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_cache_get_max_buffer_extents ();
+  data = malloc (max_extent);
+  if (data == NULL)
+    return XDG_MIME_TYPE_UNKNOWN;
+        
+  file = fopen (file_name, "r");
+  if (file == NULL)
+    {
+      free (data);
+      return XDG_MIME_TYPE_UNKNOWN;
+    }
+
+  bytes_read = fread (data, 1, max_extent, file);
+  if (ferror (file))
+    {
+      free (data);
+      fclose (file);
+      return XDG_MIME_TYPE_UNKNOWN;
+    }
+
+  mime_type = cache_get_mime_type_for_data (data, bytes_read,
+                                           mime_types, n);
+
+  free (data);
+  fclose (file);
+
+  return mime_type;
+}
+
+const char *
+_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
+{
+  const char *mime_types[2];
+
+  if (cache_glob_lookup_file_name (file_name, mime_types, 2) == 1)
+    return mime_types[0];
+  else
+    return XDG_MIME_TYPE_UNKNOWN;
+}
+
+#if 1
+static int
+is_super_type (const char *mime)
+{
+  int length;
+  const char *type;
+
+  length = strlen (mime);
+  type = &(mime[length - 2]);
+
+  if (strcmp (type, "/*") == 0)
+    return 1;
+
+  return 0;
+}
+#endif
+
+int
+_xdg_mime_cache_mime_type_subclass (const char *mime,
+                                   const char *base)
+{
+  const char *umime, *ubase;
+
+  int i, j, min, max, med, cmp;
+  
+  umime = _xdg_mime_cache_unalias_mime_type (mime);
+  ubase = _xdg_mime_cache_unalias_mime_type (base);
+
+  if (strcmp (umime, ubase) == 0)
+    return 1;
+
+  /* We really want to handle text/ * in GtkFileFilter, so we just
+   * turn on the supertype matching
+   */
+#if 1
+  /* Handle supertypes */
+  if (is_super_type (ubase) &&
+      xdg_mime_media_type_equal (umime, ubase))
+    return 1;
+#endif
+
+  /*  Handle special cases text/plain and application/octet-stream */
+  if (strcmp (ubase, "text/plain") == 0 && 
+      strncmp (umime, "text/", 5) == 0)
+    return 1;
+
+  if (strcmp (ubase, "application/octet-stream") == 0)
+    return 1;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+      
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+      xdg_uint32_t offset, n_parents, parent_offset;
+
+      min = 0; 
+      max = n_entries - 1;
+      while (max >= min)
+       {
+         med = (min + max)/2;
+         
+         offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med);
+         cmp = strcmp (cache->buffer + offset, umime);
+         if (cmp < 0)
+           min = med + 1;
+         else if (cmp > 0)
+           max = med - 1;
+         else
+           {
+             offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * med + 4);
+             n_parents = GET_UINT32 (cache->buffer, offset);
+             
+             for (j = 0; j < n_parents; j++)
+               {
+                 parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
+                 if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
+                   return 1;
+               }
+
+             break;
+           }
+       }
+    }
+
+  return 0;
+}
+
+const char *
+_xdg_mime_cache_unalias_mime_type (const char *mime)
+{
+  const char *lookup;
+  
+  lookup = cache_alias_lookup (mime);
+  
+  if (lookup)
+    return lookup;
+  
+  return mime;  
+}
+
+char **
+_xdg_mime_cache_list_mime_parents (const char *mime)
+{
+  int i, j, p;
+  char *all_parents[128]; /* we'll stop at 128 */ 
+  char **result;
+
+  mime = xdg_mime_unalias_mime_type (mime);
+
+  p = 0;
+  for (i = 0; _xdg_mime_caches[i]; i++)
+    {
+      XdgMimeCache *cache = _xdg_mime_caches[i];
+
+      xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
+      xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
+
+      for (j = 0; j < n_entries; j++)
+       {
+         xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j);
+         xdg_uint32_t parents_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 8 * j + 4);
+
+         if (strcmp (cache->buffer + mimetype_offset, mime) == 0)
+           {
+             int k;
+             xdg_uint32_t parent_mime_offset;
+             xdg_uint32_t n_parents = GET_UINT32 (cache->buffer, parents_offset);
+
+             for (k = 0; k < n_parents && p < 127; k++)
+               {
+                 parent_mime_offset = GET_UINT32 (cache->buffer, parents_offset + 4 + 4 * k);
+                 all_parents[p++] = cache->buffer + parent_mime_offset;
+               }
+
+             break;
+           }
+       }
+    }
+  all_parents[p++] = 0;
+  
+  result = (char **) malloc (p * sizeof (char *));
+  memcpy (result, all_parents, p * sizeof (char *));
+
+  return result;
+}
+
diff --git a/libcitadel/lib/xdgmime/xdgmimecache.h b/libcitadel/lib/xdgmime/xdgmimecache.h
new file mode 100644 (file)
index 0000000..0077fec
--- /dev/null
@@ -0,0 +1,74 @@
+/* -*- 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(mime_cache_new_from_file)
+#define _xdg_mime_cache_ref                          XDG_RESERVED_ENTRY(mime_cache_ref)
+#define _xdg_mime_cache_unref                        XDG_RESERVED_ENTRY(mime_cache_unref)
+#define _xdg_mime_cache_get_mime_type_for_data       XDG_RESERVED_ENTRY(mime_cache_get_mime_type_for_data)
+#define _xdg_mime_cache_get_mime_type_for_file       XDG_RESERVED_ENTRY(mime_cache_get_mime_type_for_file)
+#define _xdg_mime_cache_get_mime_type_from_file_name XDG_RESERVED_ENTRY(mime_cache_get_mime_type_from_file_name)
+#define _xdg_mime_cache_is_valid_mime_type           XDG_RESERVED_ENTRY(mime_cache_is_valid_mime_type)
+#define _xdg_mime_cache_mime_type_equal              XDG_RESERVED_ENTRY(mime_cache_mime_type_equal)
+#define _xdg_mime_cache_media_type_equal             XDG_RESERVED_ENTRY(mime_cache_media_type_equal)
+#define _xdg_mime_cache_mime_type_subclass           XDG_RESERVED_ENTRY(mime_cache_mime_type_subclass)
+#define _xdg_mime_cache_list_mime_parents            XDG_RESERVED_ENTRY(mime_cache_list_mime_parents)
+#define _xdg_mime_cache_unalias_mime_type            XDG_RESERVED_ENTRY(mime_cache_unalias_mime_type)
+#define _xdg_mime_cache_get_max_buffer_extents       XDG_RESERVED_ENTRY(mime_cache_get_max_buffer_extents)
+#define _xdg_mime_caches                             XDG_RESERVED_ENTRY(mime_caches)
+#endif
+
+extern XdgMimeCache **_xdg_mime_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);
+const char  *_xdg_mime_cache_get_mime_type_for_file       (const char  *file_name,
+                                                          struct stat *statbuf);
+const char  *_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name);
+int          _xdg_mime_cache_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);
+
+#endif /* __XDG_MIME_CACHE_H__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimeglob.c b/libcitadel/lib/xdgmime/xdgmimeglob.c
new file mode 100644 (file)
index 0000000..2a88a59
--- /dev/null
@@ -0,0 +1,550 @@
+/* -*- 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;
+  XdgGlobHashNode *next;
+  XdgGlobHashNode *child;
+};
+struct XdgGlobList
+{
+  const char *data;
+  const char *mime_type;
+  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 it's 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)
+{
+  XdgGlobList *new_element;
+  XdgGlobList *tmp_element;
+
+  new_element = _xdg_glob_list_new ();
+  new_element->data = data;
+  new_element->mime_type = mime_type;
+  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;
+}
+
+#if 0
+static XdgGlobList *
+_xdg_glob_list_prepend (XdgGlobList *glob_list,
+                       void        *data,
+                       const char  *mime_type)
+{
+  XdgGlobList *new_element;
+
+  new_element = _xdg_glob_list_new ();
+  new_element->data = data;
+  new_element->next = glob_list;
+  new_element->mime_type = mime_type;
+
+  return new_element;
+}
+#endif
+
+/* 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\n", glob_hash_node->mime_type);
+  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_text (XdgGlobHashNode *glob_hash_node,
+                           const char      *text,
+                           const char      *mime_type)
+{
+  XdgGlobHashNode *node;
+  xdg_unichar_t character;
+
+  character = _xdg_utf8_to_ucs4 (text);
+
+  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 = _xdg_utf8_next_char (text);
+  if (*text == '\000')
+    {
+      if (node->mime_type)
+       {
+         if (strcmp (node->mime_type, mime_type))
+           {
+             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 = '\000';
+                 child->mime_type = strdup (mime_type);
+                 child->child = NULL;
+                 child->next = node->child;
+                 node->child = child;
+               }
+           }
+       }
+      else
+       {
+         node->mime_type = strdup (mime_type);
+       }
+    }
+  else
+    {
+      node->child = _xdg_glob_hash_insert_text (node->child, text, mime_type);
+    }
+  return glob_hash_node;
+}
+
+static int
+_xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
+                                     const char      *file_name,
+                                     int              ignore_case,
+                                     const char      *mime_types[],
+                                     int              n_mime_types)
+{
+  int n;
+  XdgGlobHashNode *node;
+  xdg_unichar_t character;
+
+  if (glob_hash_node == NULL)
+    return 0;
+
+  character = _xdg_utf8_to_ucs4 (file_name);
+  if (ignore_case)
+    character = _xdg_ucs4_to_lower(character);
+
+  for (node = glob_hash_node; node && character >= node->character; node = node->next)
+    {
+      if (character == node->character)
+       {
+         file_name = _xdg_utf8_next_char (file_name);
+         if (*file_name == '\000')
+           {
+             n = 0;
+
+             if (node->mime_type != NULL)
+               mime_types[n++] = node->mime_type;
+
+             node = node->child;
+             while (n < n_mime_types && node && node->character == 0)
+               {
+                 if (node->mime_type != NULL)
+                   mime_types[n++] = node->mime_type;
+
+                 node = node->next;
+               }
+           }
+         else
+           {
+             n = _xdg_glob_hash_node_lookup_file_name (node->child,
+                                                       file_name,
+                                                       ignore_case,
+                                                       mime_types,
+                                                       n_mime_types);
+           }
+         return n;
+       }
+    }
+
+  return 0;
+}
+
+int
+_xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
+                                const char  *file_name,
+                                const char  *mime_types[],
+                                int          n_mime_types)
+{
+  XdgGlobList *list;
+  const char *ptr;
+  char stopchars[128];
+  int i, n;
+  XdgGlobHashNode *node;
+
+  /* First, check the literals */
+
+  assert (file_name != NULL && n_mime_types > 0);
+
+  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;
+         return 1;
+       }
+    }
+
+  i = 0;
+  for (node = glob_hash->simple_node; node; node = node->next)
+    {
+      if (node->character < 128)
+       stopchars[i++] = (char)node->character;
+    }
+  stopchars[i] = '\0';
+  ptr = strpbrk (file_name, stopchars);
+  while (ptr)
+    {
+      n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ptr, FALSE,
+                                               mime_types, n_mime_types);
+      if (n > 0)
+       return n;
+      
+      n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ptr, TRUE,
+                                               mime_types, n_mime_types);
+      if (n > 0)
+       return n;
+      
+      ptr = strpbrk (ptr + 1, stopchars);
+    }
+
+  /* FIXME: Not UTF-8 safe */
+  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)
+       mime_types[n++] = list->mime_type;
+    }
+
+  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 != '\000')
+    {
+      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)
+{
+  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));
+      break;
+    case XDG_GLOB_SIMPLE:
+      glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, mime_type);
+      break;
+    case XDG_GLOB_FULL:
+      glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type));
+      break;
+    }
+}
+
+void
+_xdg_glob_hash_dump (XdgGlobHash *glob_hash)
+{
+  XdgGlobList *list;
+  printf ("LITERAL STRINGS\n");
+  if (glob_hash->literal_list == NULL)
+    {
+      printf ("    None\n");
+    }
+  else
+    {
+      for (list = glob_hash->literal_list; list; list = list->next)
+       printf ("    %s - %s\n", (char *)list->data, list->mime_type);
+    }
+  printf ("\nSIMPLE GLOBS\n");
+  _xdg_glob_hash_node_dump (glob_hash->simple_node, 4);
+
+  printf ("\nFULL GLOBS\n");
+  if (glob_hash->full_list == NULL)
+    {
+      printf ("    None\n");
+    }
+  else
+    {
+      for (list = glob_hash->full_list; list; list = list->next)
+       printf ("    %s - %s\n", (char *)list->data, list->mime_type);
+    }
+}
+
+
+void
+_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
+                              const char  *file_name)
+{
+  FILE *glob_file;
+  char line[255];
+
+  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;
+      if (line[0] == '#')
+       continue;
+
+      colon = strchr (line, ':');
+      if (colon == NULL)
+       continue;
+      *(colon++) = '\000';
+      colon[strlen (colon) -1] = '\000';
+      _xdg_glob_hash_append_glob (glob_hash, colon, line);
+    }
+
+  fclose (glob_file);
+}
diff --git a/libcitadel/lib/xdgmime/xdgmimeglob.h b/libcitadel/lib/xdgmime/xdgmimeglob.h
new file mode 100644 (file)
index 0000000..0e2d2bf
--- /dev/null
@@ -0,0 +1,67 @@
+/* -*- 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(mime_glob_read_from_file)
+#define _xdg_glob_hash_new                    XDG_RESERVED_ENTRY(glob_hash_new)
+#define _xdg_glob_hash_free                   XDG_RESERVED_ENTRY(glob_hash_free)
+#define _xdg_glob_hash_lookup_file_name       XDG_RESERVED_ENTRY(glob_hash_lookup_file_name)
+#define _xdg_glob_hash_append_glob            XDG_RESERVED_ENTRY(glob_hash_append_glob)
+#define _xdg_glob_determine_type              XDG_RESERVED_ENTRY(glob_determine_type)
+#define _xdg_glob_hash_dump                   XDG_RESERVED_ENTRY(glob_hash_dump)
+#endif
+
+void         _xdg_mime_glob_read_from_file   (XdgGlobHash *glob_hash,
+                                             const char  *file_name);
+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);
+XdgGlobType  _xdg_glob_determine_type        (const char  *glob);
+void         _xdg_glob_hash_dump             (XdgGlobHash *glob_hash);
+
+#endif /* __XDG_MIME_GLOB_H__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimeint.c b/libcitadel/lib/xdgmime/xdgmimeint.c
new file mode 100644 (file)
index 0000000..4a0ac4c
--- /dev/null
@@ -0,0 +1,154 @@
+/* -*- 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;
+}
diff --git a/libcitadel/lib/xdgmime/xdgmimeint.h b/libcitadel/lib/xdgmime/xdgmimeint.h
new file mode 100644 (file)
index 0000000..09af88a
--- /dev/null
@@ -0,0 +1,73 @@
+/* -*- 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)
+#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);
+const char    *_xdg_get_base_name (const char    *file_name);
+
+#endif /* __XDG_MIME_INT_H__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimemagic.c b/libcitadel/lib/xdgmime/xdgmimemagic.c
new file mode 100644 (file)
index 0000000..5441e6d
--- /dev/null
@@ -0,0 +1,823 @@
+/* -*- 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)
+    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;
+  int 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 != 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 != 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 == -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)
+       {
+#if LITTLE_ENDIAN
+         int i;
+#endif
+         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)
+{
+  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,
+                             const char   *mime_types[],
+                             int           n_mime_types)
+{
+  XdgMimeMagicMatch *match;
+  const char *mime_type;
+  int n;
+  int priority;
+  int had_match;
+
+  mime_type = NULL;
+  priority = 0;
+  had_match = 0;
+  for (match = mime_magic->match_list; match; match = match->next)
+    {
+      if (_xdg_mime_magic_match_compare_to_data (match, data, len))
+       {
+         if (!had_match || match->priority > priority ||
+             (mime_type != NULL && _xdg_mime_mime_type_subclass (match->mime_type, mime_type)))
+           {
+             mime_type = match->mime_type;
+             priority = match->priority;
+           }
+         else if (had_match && match->priority == priority &&
+                  !_xdg_mime_mime_type_subclass (mime_type, match->mime_type))
+           /* multiple unrelated patterns with the same priority matched,
+            * so we can't tell what type this is. */
+           mime_type = NULL;
+
+         had_match = 1;
+       }
+      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];
+       }
+    }
+
+  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);
+}
diff --git a/libcitadel/lib/xdgmime/xdgmimemagic.h b/libcitadel/lib/xdgmime/xdgmimemagic.h
new file mode 100644 (file)
index 0000000..26424fa
--- /dev/null
@@ -0,0 +1,55 @@
+/* -*- 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_magic_new                       XDG_RESERVED_ENTRY(mime_magic_new)
+#define _xdg_mime_magic_read_from_file            XDG_RESERVED_ENTRY(mime_magic_read_from_file)
+#define _xdg_mime_magic_free                      XDG_RESERVED_ENTRY(mime_magic_free)
+#define _xdg_mime_magic_get_buffer_extents        XDG_RESERVED_ENTRY(mime_magic_get_buffer_extents)
+#define _xdg_mime_magic_lookup_data               XDG_RESERVED_ENTRY(mime_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,
+                                                 const char   *mime_types[],
+                                                 int           n_mime_types);
+
+#endif /* __XDG_MIME_MAGIC_H__ */
diff --git a/libcitadel/lib/xdgmime/xdgmimeparent.c b/libcitadel/lib/xdgmime/xdgmimeparent.c
new file mode 100644 (file)
index 0000000..511bbac
--- /dev/null
@@ -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);
+       }
+    }
+}
+
+
diff --git a/libcitadel/lib/xdgmime/xdgmimeparent.h b/libcitadel/lib/xdgmime/xdgmimeparent.h
new file mode 100644 (file)
index 0000000..e98f794
--- /dev/null
@@ -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(mime_parent_read_from_file)
+#define _xdg_mime_parent_list_new              XDG_RESERVED_ENTRY(mime_parent_list_new)
+#define _xdg_mime_parent_list_free             XDG_RESERVED_ENTRY(mime_parent_list_free)
+#define _xdg_mime_parent_list_lookup           XDG_RESERVED_ENTRY(mime_parent_list_lookup)
+#define _xdg_mime_parent_list_dump             XDG_RESERVED_ENTRY(mime_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__ */