Add a condition to FcCacheOffsetsValid() for detecting empty data of cache
[platform/upstream/fontconfig.git] / src / fccache.c
index dd0896b..f9e66e8 100644 (file)
@@ -6,39 +6,44 @@
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
  *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-
 #include "fcint.h"
-#include "../fc-arch/fcarch.h"
+#include "fcarch.h"
 #include <stdio.h>
+#include <stdlib.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <string.h>
+#include <limits.h>
 #include <sys/types.h>
+#include <sys/stat.h>
+#include <assert.h>
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 #  include <unistd.h>
 #  include <sys/mman.h>
-#elif defined(_WIN32)
-#  include <windows.h>
+#endif
+#if defined(_WIN32)
+#include <sys/locking.h>
 #endif
 
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
 
+
 struct MD5Context {
         FcChar32 buf[4];
         FcChar32 bits[2];
@@ -46,12 +51,43 @@ struct MD5Context {
 };
 
 static void MD5Init(struct MD5Context *ctx);
-static void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned len);
+static void MD5Update(struct MD5Context *ctx, const unsigned char *buf, unsigned len);
 static void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
 static void MD5Transform(FcChar32 buf[4], FcChar32 in[16]);
 
 #define CACHEBASE_LEN (1 + 32 + 1 + sizeof (FC_ARCHITECTURE) + sizeof (FC_CACHE_SUFFIX))
 
+static FcBool
+FcCacheIsMmapSafe (int fd)
+{
+    enum {
+      MMAP_NOT_INITIALIZED = 0,
+      MMAP_USE,
+      MMAP_DONT_USE,
+      MMAP_CHECK_FS,
+    } status;
+    static void *static_status;
+
+    status = (intptr_t) fc_atomic_ptr_get (&static_status);
+
+    if (status == MMAP_NOT_INITIALIZED)
+    {
+       const char *env = getenv ("FONTCONFIG_USE_MMAP");
+       FcBool use;
+       if (env && FcNameBool ((const FcChar8 *) env, &use))
+           status =  use ? MMAP_USE : MMAP_DONT_USE;
+       else
+           status = MMAP_CHECK_FS;
+       (void) fc_atomic_ptr_cmpexch (&static_status, NULL, (void *) status);
+    }
+
+    if (status == MMAP_CHECK_FS)
+       return FcIsFsMmapSafe (fd);
+    else
+       return status == MMAP_USE;
+
+}
+
 static const char bin2hex[] = { '0', '1', '2', '3',
                                '4', '5', '6', '7',
                                '8', '9', 'a', 'b',
@@ -66,7 +102,7 @@ FcDirCacheBasename (const FcChar8 * dir, FcChar8 cache_base[CACHEBASE_LEN])
     struct MD5Context  ctx;
 
     MD5Init (&ctx);
-    MD5Update (&ctx, (unsigned char *)dir, strlen ((char *) dir));
+    MD5Update (&ctx, (const unsigned char *)dir, strlen ((const char *) dir));
 
     MD5Final (hash, &ctx);
 
@@ -90,6 +126,7 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config)
     FcChar8    cache_base[CACHEBASE_LEN];
     FcStrList  *list;
     FcChar8    *cache_dir;
+    const FcChar8 *sysroot = FcConfigGetSysRoot (config);
 
     FcDirCacheBasename (dir, cache_base);
 
@@ -99,10 +136,14 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config)
        
     while ((cache_dir = FcStrListNext (list)))
     {
-        cache_hashed = FcStrPlus (cache_dir, cache_base);
+       if (sysroot)
+           cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL);
+       else
+           cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL);
         if (!cache_hashed)
            break;
        (void) unlink ((char *) cache_hashed);
+       FcStrFree (cache_hashed);
     }
     FcStrListDone (list);
     /* return FcFalse if something went wrong */
@@ -112,102 +153,56 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config)
 }
 
 static int
-FcCacheReadDirs (FcConfig * config,
-                FcStrList *list, FcFontSet * set, FcStrSet *processed_dirs)
+FcDirCacheOpenFile (const FcChar8 *cache_file, struct stat *file_stat)
 {
-    int                        ret = 0;
-    FcChar8            *dir;
-    FcStrSet           *subdirs;
-    FcStrList          *sublist;
+    int        fd;
 
-    /*
-     * Read in the results from 'list'.
-     */
-    while ((dir = FcStrListNext (list)))
+#ifdef _WIN32
+    if (FcStat (cache_file, file_stat) < 0)
+        return -1;
+#endif
+    fd = FcOpen((char *) cache_file, O_RDONLY | O_BINARY);
+    if (fd < 0)
+       return fd;
+#ifndef _WIN32
+    if (fstat (fd, file_stat) < 0)
     {
-       if (!FcConfigAcceptFilename (config, dir))
-           continue;
-
-       /* Skip this directory if already updated
-        * to avoid the looped directories via symlinks
-        * Clearly a dir not in fonts.conf shouldn't be globally cached.
-        */
-
-       if (FcStrSetMember (processed_dirs, dir))
-           continue;
-       if (!FcStrSetAdd (processed_dirs, dir))
-           continue;
-
-       subdirs = FcStrSetCreate ();
-       if (!subdirs)
-       {
-           fprintf (stderr, "Can't create directory set\n");
-           ret++;
-           continue;
-       }
-       
-       FcDirScanConfig (set, subdirs,
-                        config->blanks, dir, FcFalse, config);
-       
-       sublist = FcStrListCreate (subdirs);
-       FcStrSetDestroy (subdirs);
-       if (!sublist)
-       {
-           fprintf (stderr, "Can't create subdir list in \"%s\"\n", dir);
-           ret++;
-           continue;
-       }
-       ret += FcCacheReadDirs (config, sublist, set, processed_dirs);
+       close (fd);
+       return -1;
     }
-    FcStrListDone (list);
-    return ret;
-}
-
-FcFontSet *
-FcCacheRead (FcConfig *config)
-{
-    FcFontSet  *s = FcFontSetCreate();
-    FcStrSet   *processed_dirs;
-
-    if (!s) 
-       return 0;
-
-    processed_dirs = FcStrSetCreate();
-    if (!processed_dirs)
-       goto bail;
-
-    if (FcCacheReadDirs (config, FcConfigGetConfigDirs (config), s, processed_dirs))
-       goto bail1;
-
-    FcStrSetDestroy (processed_dirs);
-    return s;
-
- bail1:
-    FcStrSetDestroy (processed_dirs);
- bail:
-    FcFontSetDestroy (s);
-    return 0;
+#endif
+    return fd;
 }
 
-/* 
+/*
  * Look for a cache file for the specified dir. Attempt
  * to use each one we find, stopping when the callback
  * indicates success
  */
 static FcBool
-FcDirCacheProcess (FcConfig *config, const FcChar8 *dir, 
-                  FcBool (*callback) (int fd, off_t size, void *closure),
+FcDirCacheProcess (FcConfig *config, const FcChar8 *dir,
+                  FcBool (*callback) (FcConfig *config, int fd, struct stat *fd_stat,
+                                      struct stat *dir_stat, void *closure),
                   void *closure, FcChar8 **cache_file_ret)
 {
     int                fd = -1;
     FcChar8    cache_base[CACHEBASE_LEN];
     FcStrList  *list;
-    FcChar8    *cache_dir;
+    FcChar8    *cache_dir, *d;
     struct stat file_stat, dir_stat;
     FcBool     ret = FcFalse;
+    const FcChar8 *sysroot = FcConfigGetSysRoot (config);
 
-    if (stat ((char *) dir, &dir_stat) < 0)
+    if (sysroot)
+       d = FcStrBuildFilename (sysroot, dir, NULL);
+    else
+       d = FcStrdup (dir);
+    if (FcStatChecksum (d, &dir_stat) < 0)
+    {
+       FcStrFree (d);
         return FcFalse;
+    }
+    FcStrFree (d);
 
     FcDirCacheBasename (dir, cache_base);
 
@@ -217,179 +212,661 @@ FcDirCacheProcess (FcConfig *config, const FcChar8 *dir,
        
     while ((cache_dir = FcStrListNext (list)))
     {
-        FcChar8        *cache_hashed = FcStrPlus (cache_dir, cache_base);
+        FcChar8        *cache_hashed;
+
+       if (sysroot)
+           cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL);
+       else
+           cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL);
         if (!cache_hashed)
            break;
-        fd = open((char *) cache_hashed, O_RDONLY | O_BINARY);
+        fd = FcDirCacheOpenFile (cache_hashed, &file_stat);
         if (fd >= 0) {
-           if (fstat (fd, &file_stat) >= 0 &&
-               dir_stat.st_mtime <= file_stat.st_mtime)
+           ret = (*callback) (config, fd, &file_stat, &dir_stat, closure);
+           close (fd);
+           if (ret)
            {
-               ret = (*callback) (fd, file_stat.st_size, closure);
-               if (ret)
-               {
-                   if (cache_file_ret)
-                       *cache_file_ret = cache_hashed;
-                   else
-                       FcStrFree (cache_hashed);
-                   close (fd);
-                   break;
-               }
+               if (cache_file_ret)
+                   *cache_file_ret = cache_hashed;
+               else
+                   FcStrFree (cache_hashed);
+               break;
            }
-           close (fd);
        }
        FcStrFree (cache_hashed);
     }
     FcStrListDone (list);
-    
+
     return ret;
 }
 
-FcBool
-FcDirCacheLoad (int fd, off_t size, void *closure)
+#define FC_CACHE_MIN_MMAP   1024
+
+/*
+ * Skip list element, make sure the 'next' pointer is the last thing
+ * in the structure, it will be allocated large enough to hold all
+ * of the necessary pointers
+ */
+
+typedef struct _FcCacheSkip FcCacheSkip;
+
+struct _FcCacheSkip {
+    FcCache        *cache;
+    FcRef          ref;
+    intptr_t       size;
+    dev_t          cache_dev;
+    ino_t          cache_ino;
+    time_t         cache_mtime;
+    long           cache_mtime_nano;
+    FcCacheSkip            *next[1];
+};
+
+/*
+ * The head of the skip list; pointers for every possible level
+ * in the skip list, plus the largest level in the list
+ */
+
+#define FC_CACHE_MAX_LEVEL  16
+
+/* Protected by cache_lock below */
+static FcCacheSkip     *fcCacheChains[FC_CACHE_MAX_LEVEL];
+static int             fcCacheMaxLevel;
+
+
+static FcMutex *cache_lock;
+
+static void
+lock_cache (void)
 {
-    FcCache    *cache;
-    FcBool     allocated = FcFalse;
+  FcMutex *lock;
+retry:
+  lock = fc_atomic_ptr_get (&cache_lock);
+  if (!lock) {
+    lock = (FcMutex *) malloc (sizeof (FcMutex));
+    FcMutexInit (lock);
+    if (!fc_atomic_ptr_cmpexch (&cache_lock, NULL, lock)) {
+      FcMutexFinish (lock);
+      goto retry;
+    }
+
+    FcMutexLock (lock);
+    /* Initialize random state */
+    FcRandom ();
+    return;
+  }
+  FcMutexLock (lock);
+}
+
+static void
+unlock_cache (void)
+{
+  FcMutexUnlock (cache_lock);
+}
+
+static void
+free_lock (void)
+{
+  FcMutex *lock;
+  lock = fc_atomic_ptr_get (&cache_lock);
+  if (lock && fc_atomic_ptr_cmpexch (&cache_lock, lock, NULL)) {
+    FcMutexFinish (lock);
+    free (lock);
+  }
+}
+
+
+
+/*
+ * Generate a random level number, distributed
+ * so that each level is 1/4 as likely as the one before
+ *
+ * Note that level numbers run 1 <= level <= MAX_LEVEL
+ */
+static int
+random_level (void)
+{
+    /* tricky bit -- each bit is '1' 75% of the time */
+    long int   bits = FcRandom () | FcRandom ();
+    int        level = 0;
+
+    while (++level < FC_CACHE_MAX_LEVEL)
+    {
+       if (bits & 1)
+           break;
+       bits >>= 1;
+    }
+    return level;
+}
+
+/*
+ * Insert cache into the list
+ */
+static FcBool
+FcCacheInsert (FcCache *cache, struct stat *cache_stat)
+{
+    FcCacheSkip    **update[FC_CACHE_MAX_LEVEL];
+    FcCacheSkip    *s, **next;
+    int                    i, level;
 
-    if (size < sizeof (FcCache))
+    lock_cache ();
+
+    /*
+     * Find links along each chain
+     */
+    next = fcCacheChains;
+    for (i = fcCacheMaxLevel; --i >= 0; )
+    {
+       for (; (s = next[i]); next = s->next)
+           if (s->cache > cache)
+               break;
+        update[i] = &next[i];
+    }
+
+    /*
+     * Create new list element
+     */
+    level = random_level ();
+    if (level > fcCacheMaxLevel)
+    {
+       level = fcCacheMaxLevel + 1;
+       update[fcCacheMaxLevel] = &fcCacheChains[fcCacheMaxLevel];
+       fcCacheMaxLevel = level;
+    }
+
+    s = malloc (sizeof (FcCacheSkip) + (level - 1) * sizeof (FcCacheSkip *));
+    if (!s)
        return FcFalse;
+
+    s->cache = cache;
+    s->size = cache->size;
+    FcRefInit (&s->ref, 1);
+    if (cache_stat)
+    {
+       s->cache_dev = cache_stat->st_dev;
+       s->cache_ino = cache_stat->st_ino;
+       s->cache_mtime = cache_stat->st_mtime;
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+       s->cache_mtime_nano = cache_stat->st_mtim.tv_nsec;
+#else
+       s->cache_mtime_nano = 0;
+#endif
+    }
+    else
+    {
+       s->cache_dev = 0;
+       s->cache_ino = 0;
+       s->cache_mtime = 0;
+       s->cache_mtime_nano = 0;
+    }
+
+    /*
+     * Insert into all fcCacheChains
+     */
+    for (i = 0; i < level; i++)
+    {
+       s->next[i] = *update[i];
+       *update[i] = s;
+    }
+
+    unlock_cache ();
+    return FcTrue;
+}
+
+static FcCacheSkip *
+FcCacheFindByAddrUnlocked (void *object)
+{
+    int            i;
+    FcCacheSkip    **next = fcCacheChains;
+    FcCacheSkip    *s;
+
+    if (!object)
+       return NULL;
+
+    /*
+     * Walk chain pointers one level at a time
+     */
+    for (i = fcCacheMaxLevel; --i >= 0;)
+       while (next[i] && (char *) object >= ((char *) next[i]->cache + next[i]->size))
+           next = next[i]->next;
+    /*
+     * Here we are
+     */
+    s = next[0];
+    if (s && (char *) object < ((char *) s->cache + s->size))
+       return s;
+    return NULL;
+}
+
+static FcCacheSkip *
+FcCacheFindByAddr (void *object)
+{
+    FcCacheSkip *ret;
+    lock_cache ();
+    ret = FcCacheFindByAddrUnlocked (object);
+    unlock_cache ();
+    return ret;
+}
+
+static void
+FcCacheRemoveUnlocked (FcCache *cache)
+{
+    FcCacheSkip            **update[FC_CACHE_MAX_LEVEL];
+    FcCacheSkip            *s, **next;
+    int                    i;
+
+    /*
+     * Find links along each chain
+     */
+    next = fcCacheChains;
+    for (i = fcCacheMaxLevel; --i >= 0; )
+    {
+       for (; (s = next[i]); next = s->next)
+           if (s->cache >= cache)
+               break;
+        update[i] = &next[i];
+    }
+    s = next[0];
+    for (i = 0; i < fcCacheMaxLevel && *update[i] == s; i++)
+       *update[i] = s->next[i];
+    while (fcCacheMaxLevel > 0 && fcCacheChains[fcCacheMaxLevel - 1] == NULL)
+       fcCacheMaxLevel--;
+    free (s);
+}
+
+static FcCache *
+FcCacheFindByStat (struct stat *cache_stat)
+{
+    FcCacheSkip            *s;
+
+    lock_cache ();
+    for (s = fcCacheChains[0]; s; s = s->next[0])
+       if (s->cache_dev == cache_stat->st_dev &&
+           s->cache_ino == cache_stat->st_ino &&
+           s->cache_mtime == cache_stat->st_mtime)
+       {
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+           if (s->cache_mtime != cache_stat->st_mtim.tv_nsec)
+               continue;
+#endif
+           FcRefInc (&s->ref);
+           unlock_cache ();
+           return s->cache;
+       }
+    unlock_cache ();
+    return NULL;
+}
+
+static void
+FcDirCacheDisposeUnlocked (FcCache *cache)
+{
+    FcCacheRemoveUnlocked (cache);
+
+    switch (cache->magic) {
+    case FC_CACHE_MAGIC_ALLOC:
+       free (cache);
+       break;
+    case FC_CACHE_MAGIC_MMAP:
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
-    cache = mmap (0, size, PROT_READ, MAP_SHARED, fd, 0);
+       munmap (cache, cache->size);
 #elif defined(_WIN32)
+       UnmapViewOfFile (cache);
+#endif
+       break;
+    }
+}
+
+void
+FcCacheObjectReference (void *object)
+{
+    FcCacheSkip *skip = FcCacheFindByAddr (object);
+
+    if (skip)
+       FcRefInc (&skip->ref);
+}
+
+void
+FcCacheObjectDereference (void *object)
+{
+    FcCacheSkip        *skip;
+
+    lock_cache ();
+    skip = FcCacheFindByAddrUnlocked (object);
+    if (skip)
     {
-       HANDLE hFileMap;
+       if (FcRefDec (&skip->ref) == 1)
+           FcDirCacheDisposeUnlocked (skip->cache);
+    }
+    unlock_cache ();
+}
 
-       cache = NULL;
-       hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL,
-                                    PAGE_READONLY, 0, 0, NULL);
-       if (hFileMap != NULL)
+void
+FcCacheFini (void)
+{
+    int                    i;
+
+    for (i = 0; i < FC_CACHE_MAX_LEVEL; i++)
+       assert (fcCacheChains[i] == NULL);
+    assert (fcCacheMaxLevel == 0);
+
+    free_lock ();
+}
+
+static FcBool
+FcCacheTimeValid (FcConfig *config, FcCache *cache, struct stat *dir_stat)
+{
+    struct stat        dir_static;
+    FcBool fnano = FcTrue;
+
+    if (!dir_stat)
+    {
+       const FcChar8 *sysroot = FcConfigGetSysRoot (config);
+       FcChar8 *d;
+
+       if (sysroot)
+           d = FcStrBuildFilename (sysroot, FcCacheDir (cache), NULL);
+       else
+           d = FcStrdup (FcCacheDir (cache));
+       if (FcStatChecksum (d, &dir_static) < 0)
        {
-           cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0, size);
-           CloseHandle (hFileMap);
+           FcStrFree (d);
+           return FcFalse;
        }
+       FcStrFree (d);
+       dir_stat = &dir_static;
+    }
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+    fnano = (cache->checksum_nano == dir_stat->st_mtim.tv_nsec);
+    if (FcDebug () & FC_DBG_CACHE)
+       printf ("FcCacheTimeValid dir \"%s\" cache checksum %d.%ld dir checksum %d.%ld\n",
+               FcCacheDir (cache), cache->checksum, (long)cache->checksum_nano, (int) dir_stat->st_mtime, dir_stat->st_mtim.tv_nsec);
+#else
+    if (FcDebug () & FC_DBG_CACHE)
+       printf ("FcCacheTimeValid dir \"%s\" cache checksum %d dir checksum %d\n",
+               FcCacheDir (cache), cache->checksum, (int) dir_stat->st_mtime);
+#endif
+
+    return cache->checksum == (int) dir_stat->st_mtime && fnano;
+}
+
+static FcBool
+FcCacheOffsetsValid (FcCache *cache)
+{
+    char               *base = (char *)cache;
+    char               *end = base + cache->size;
+    intptr_t           *dirs;
+    FcFontSet          *fs;
+    int                         i, j;
+
+    if (cache->dir < 0 || cache->dir > cache->size - sizeof (intptr_t) ||
+        memchr (base + cache->dir, '\0', cache->size - cache->dir) == NULL)
+        return FcFalse;
+
+    if (cache->dirs < 0 || cache->dirs >= cache->size ||
+        cache->dirs_count < 0 ||
+        cache->dirs_count > (cache->size - cache->dirs) / sizeof (intptr_t))
+        return FcFalse;
+
+    dirs = FcCacheDirs (cache);
+    if (dirs)
+    {
+        for (i = 0; i < cache->dirs_count; i++)
+        {
+            FcChar8    *dir;
+
+            if (dirs[i] < 0 ||
+                dirs[i] > end - (char *) dirs - sizeof (intptr_t))
+                return FcFalse;
+
+            dir = FcOffsetToPtr (dirs, dirs[i], FcChar8);
+            if (memchr (dir, '\0', end - (char *) dir) == NULL)
+                return FcFalse;
+         }
     }
+
+    if (cache->set < 0 || cache->set > cache->size - sizeof (FcFontSet))
+        return FcFalse;
+
+    fs = FcCacheSet (cache);
+    if (fs)
+    {
+        if (fs->nfont > (end - (char *) fs) / sizeof (FcPattern))
+            return FcFalse;
+
+        if (fs->fonts != 0 && !FcIsEncodedOffset(fs->fonts))
+            return FcFalse;
+
+        for (i = 0; i < fs->nfont; i++)
+        {
+            FcPattern          *font = FcFontSetFont (fs, i);
+            FcPatternElt       *e;
+            FcValueListPtr      l;
+           char                *last_offset;
+
+            /* TIZEN_ONLY(20171013): Add a condition to FcCacheOffsetsValid() for detecting empty data of cache
+            if ((char *) font < base ||
+                (char *) font > end - sizeof (FcFontSet) ||
+                font->elts_offset < 0 ||
+                font->elts_offset > end - (char *) font ||
+                font->num > (end - (char *) font - font->elts_offset) / sizeof (FcPatternElt))
+                return FcFalse;
+             */
+            if ((char *) font < base ||
+                (char *) font > end - sizeof (FcFontSet) ||
+                font->elts_offset < 0 ||
+                font->elts_offset > end - (char *) font ||
+                font->num > (end - (char *) font - font->elts_offset) / sizeof (FcPatternElt) ||
+                !FcRefIsConst (&font->ref))
+                return FcFalse;
+            /* END */
+
+
+            e = FcPatternElts(font);
+            if (e->values != 0 && !FcIsEncodedOffset(e->values))
+                return FcFalse;
+
+           for (j = 0; j < font->num; j++)
+           {
+               last_offset = (char *) font + font->elts_offset;
+               for (l = FcPatternEltValues(&e[j]); l; l = FcValueListNext(l))
+               {
+                   if ((char *) l < last_offset || (char *) l > end - sizeof (*l) ||
+                       (l->next != NULL && !FcIsEncodedOffset(l->next)))
+                       return FcFalse;
+                   last_offset = (char *) l + 1;
+               }
+           }
+        }
+    }
+
+    return FcTrue;
+}
+
+/*
+ * Map a cache file into memory
+ */
+static FcCache *
+FcDirCacheMapFd (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat)
+{
+    FcCache    *cache;
+    FcBool     allocated = FcFalse;
+
+    if (fd_stat->st_size > INTPTR_MAX ||
+        fd_stat->st_size < (int) sizeof (FcCache))
+       return NULL;
+    cache = FcCacheFindByStat (fd_stat);
+    if (cache)
+    {
+       if (FcCacheTimeValid (config, cache, dir_stat))
+           return cache;
+       FcDirCacheUnload (cache);
+       cache = NULL;
+    }
+
+    /*
+     * Large cache files are mmap'ed, smaller cache files are read. This
+     * balances the system cost of mmap against per-process memory usage.
+     */
+    if (FcCacheIsMmapSafe (fd) && fd_stat->st_size >= FC_CACHE_MIN_MMAP)
+    {
+#if defined(HAVE_MMAP) || defined(__CYGWIN__)
+       cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0);
+#if (HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
+       posix_fadvise (fd, 0, fd_stat->st_size, POSIX_FADV_WILLNEED);
+#endif
+       if (cache == MAP_FAILED)
+           cache = NULL;
+#elif defined(_WIN32)
+       {
+           HANDLE hFileMap;
+
+           cache = NULL;
+           hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL,
+                                        PAGE_READONLY, 0, 0, NULL);
+           if (hFileMap != NULL)
+           {
+               cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0,
+                                      fd_stat->st_size);
+               CloseHandle (hFileMap);
+           }
+       }
 #endif
+    }
     if (!cache)
     {
-       cache = malloc (size);
+       cache = malloc (fd_stat->st_size);
        if (!cache)
-           return FcFalse;
+           return NULL;
 
-       if (read (fd, cache, size) != size)
+       if (read (fd, cache, fd_stat->st_size) != fd_stat->st_size)
        {
            free (cache);
-           return FcFalse;
+           return NULL;
        }
        allocated = FcTrue;
-    } 
-    if (cache->magic != FC_CACHE_MAGIC ||
-       cache->size != size)
+    }
+    if (cache->magic != FC_CACHE_MAGIC_MMAP ||
+       cache->version < FC_CACHE_VERSION_NUMBER ||
+       cache->size != (intptr_t) fd_stat->st_size ||
+        !FcCacheOffsetsValid (cache) ||
+       !FcCacheTimeValid (config, cache, dir_stat) ||
+       !FcCacheInsert (cache, fd_stat))
     {
        if (allocated)
            free (cache);
        else
        {
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
-           munmap (cache, size);
+           munmap (cache, fd_stat->st_size);
 #elif defined(_WIN32)
            UnmapViewOfFile (cache);
 #endif
        }
-       return FcFalse;
+       return NULL;
     }
 
     /* Mark allocated caches so they're freed rather than unmapped */
     if (allocated)
-       cache->magic = FC_CACHE_MAGIC_COPY;
+       cache->magic = FC_CACHE_MAGIC_ALLOC;
        
+    return cache;
+}
+
+void
+FcDirCacheReference (FcCache *cache, int nref)
+{
+    FcCacheSkip *skip = FcCacheFindByAddr (cache);
+
+    if (skip)
+       FcRefAdd (&skip->ref, nref);
+}
+
+void
+FcDirCacheUnload (FcCache *cache)
+{
+    FcCacheObjectDereference (cache);
+}
+
+static FcBool
+FcDirCacheMapHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
+{
+    FcCache *cache = FcDirCacheMapFd (config, fd, fd_stat, dir_stat);
+
+    if (!cache)
+       return FcFalse;
     *((FcCache **) closure) = cache;
     return FcTrue;
 }
 
 FcCache *
-FcDirCacheMap (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file)
+FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file)
 {
     FcCache *cache = NULL;
 
     if (!FcDirCacheProcess (config, dir,
-                           FcDirCacheLoad,
+                           FcDirCacheMapHelper,
                            &cache, cache_file))
        return NULL;
+
     return cache;
 }
 
-FcBool
-FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, 
-               const FcChar8 *dir, FcConfig *config)
+FcCache *
+FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat)
 {
-    FcCache    *cache;
-    int                i;
-    FcFontSet  *cache_set;
-    intptr_t   *cache_dirs;
-    FcPattern   **cache_fonts;
+    int        fd;
+    FcCache *cache;
+    struct stat        my_file_stat;
 
-    cache = FcDirCacheMap (dir, config, NULL);
-    if (!cache)
-       return FcFalse;
-    
-    cache_set = FcCacheSet (cache);
-    cache_fonts = FcFontSetFonts(cache_set);
-    if (FcDebug() & FC_DBG_CACHE)
-        printf ("FcDirCacheRead mapped cache for %s (%d fonts %d subdirs)\n",
-               dir, cache_set->nfont, cache->dirs_count);
-    for (i = 0; i < cache_set->nfont; i++)
-    {
-       FcPattern   *font = FcEncodedOffsetToPtr (cache_set,
-                                                 cache_fonts[i],
-                                                 FcPattern);
-       if (FcDebug() & FC_DBG_CACHEV) {
-           printf ("Mapped font %d\n", i);
-           FcPatternPrint (font);
-       }
-       FcFontSetAdd (set, font);
-    }
-    
-    cache_dirs = FcCacheDirs (cache);
-    for (i = 0; i < cache->dirs_count; i++) 
-       FcStrSetAdd (dirs, FcOffsetToPtr (cache_dirs,
-                                         cache_dirs[i],
-                                         FcChar8));
-        
-    if (config)
-       FcConfigAddFontDir (config, (FcChar8 *)dir);
-    
-    return FcTrue;
+    if (!file_stat)
+       file_stat = &my_file_stat;
+    fd = FcDirCacheOpenFile (cache_file, file_stat);
+    if (fd < 0)
+       return NULL;
+    cache = FcDirCacheMapFd (FcConfigGetCurrent (), fd, file_stat, NULL);
+    close (fd);
+    return cache;
 }
-    
+
+/*
+ * Validate a cache file by reading the header and checking
+ * the magic number and the size field
+ */
 static FcBool
-FcDirCacheValidate (int fd, off_t size, void *closure)
+FcDirCacheValidateHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure FC_UNUSED)
 {
     FcBool  ret = FcTrue;
     FcCache    c;
-    struct stat        file_stat;
-    
+
     if (read (fd, &c, sizeof (FcCache)) != sizeof (FcCache))
        ret = FcFalse;
-    else if (fstat (fd, &file_stat) < 0)
+    else if (c.magic != FC_CACHE_MAGIC_MMAP)
        ret = FcFalse;
-    else if (c.magic != FC_CACHE_MAGIC)
+    else if (c.version < FC_CACHE_VERSION_NUMBER)
        ret = FcFalse;
-    else if (file_stat.st_size != c.size)
+    else if (fd_stat->st_size != c.size)
        ret = FcFalse;
+    else if (c.checksum != (int) dir_stat->st_mtime)
+       ret = FcFalse;
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+    else if (c.checksum_nano != dir_stat->st_mtim.tv_nsec)
+       ret = FcFalse;
+#endif
     return ret;
 }
 
 static FcBool
 FcDirCacheValidConfig (const FcChar8 *dir, FcConfig *config)
 {
-    return FcDirCacheProcess (config, dir, FcDirCacheValidate, NULL, NULL);
+    return FcDirCacheProcess (config, dir,
+                             FcDirCacheValidateHelper,
+                             NULL, NULL);
 }
 
 FcBool
 FcDirCacheValid (const FcChar8 *dir)
 {
     FcConfig   *config;
-    
+
     config = FcConfigGetCurrent ();
     if (!config)
         return FcFalse;
@@ -397,48 +874,25 @@ FcDirCacheValid (const FcChar8 *dir)
     return FcDirCacheValidConfig (dir, config);
 }
 
-void
-FcDirCacheUnmap (FcCache *cache)
-{
-    if (cache->magic == FC_CACHE_MAGIC_COPY)
-    {
-       free (cache);
-       return;
-    }
-#if defined(HAVE_MMAP) || defined(__CYGWIN__)
-    munmap (cache, cache->size);
-#elif defined(_WIN32)
-    UnmapViewOfFile (cache);
-#endif
-}
-
 /*
- * Cache file is:
- *
- * FcCache
- * dir name
- * subdirs
- * FcFontSet
+ * Build a cache structure from the given contents
  */
-
-static FcCache *
-FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
+FcCache *
+FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs)
 {
     FcSerialize        *serialize = FcSerializeCreate ();
     FcCache *cache;
     int i;
-    intptr_t   cache_offset;
-    intptr_t   dirs_offset;
     FcChar8    *dir_serialize;
     intptr_t   *dirs_serialize;
     FcFontSet  *set_serialize;
-    
+
     if (!serialize)
        return NULL;
     /*
      * Space for cache structure
      */
-    cache_offset = FcSerializeReserve (serialize, sizeof (FcCache));
+    FcSerializeReserve (serialize, sizeof (FcCache));
     /*
      * Directory name
      */
@@ -447,7 +901,7 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
     /*
      * Subdirs
      */
-    dirs_offset = FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
+    FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
     for (i = 0; i < dirs->num; i++)
        if (!FcStrSerializeAlloc (serialize, dirs->strs[i]))
            goto bail1;
@@ -457,7 +911,7 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
      */
     if (!FcFontSetSerializeAlloc (serialize, set))
        goto bail1;
-    
+
     /* Serialize layout complete. Now allocate space and fill it */
     cache = malloc (serialize->size);
     if (!cache)
@@ -467,8 +921,13 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
 
     serialize->linear = cache;
 
-    cache->magic = FC_CACHE_MAGIC;
+    cache->magic = FC_CACHE_MAGIC_ALLOC;
+    cache->version = FC_CACHE_VERSION_NUMBER;
     cache->size = serialize->size;
+    cache->checksum = (int) dir_stat->st_mtime;
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+    cache->checksum_nano = dir_stat->st_mtim.tv_nsec;
+#endif
 
     /*
      * Serialize directory name
@@ -477,7 +936,7 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
     if (!dir_serialize)
        goto bail2;
     cache->dir = FcPtrToOffset (cache, dir_serialize);
-    
+
     /*
      * Serialize sub dirs
      */
@@ -486,14 +945,14 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
        goto bail2;
     cache->dirs = FcPtrToOffset (cache, dirs_serialize);
     cache->dirs_count = dirs->num;
-    for (i = 0; i < dirs->num; i++) 
+    for (i = 0; i < dirs->num; i++)
     {
        FcChar8 *d_serialize = FcStrSerialize (serialize, dirs->strs[i]);
        if (!d_serialize)
            goto bail2;
        dirs_serialize[i] = FcPtrToOffset (dirs_serialize, d_serialize);
     }
-    
+
     /*
      * Serialize font set
      */
@@ -503,7 +962,9 @@ FcDirCacheProduce (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs)
     cache->set = FcPtrToOffset (cache, set_serialize);
 
     FcSerializeDestroy (serialize);
-    
+
+    FcCacheInsert (cache, NULL);
+
     return cache;
 
 bail2:
@@ -513,52 +974,56 @@ bail1:
     return NULL;
 }
 
-static FcBool
-FcMakeDirectory (const FcChar8 *dir)
+FcCache *
+FcDirCacheRebuild (FcCache *cache, struct stat *dir_stat, FcStrSet *dirs)
 {
-    FcChar8 *parent;
-    FcBool  ret;
-    
-    if (strlen ((char *) dir) == 0)
-       return FcFalse;
-    
-    parent = FcStrDirname (dir);
-    if (!parent)
-       return FcFalse;
-    if (access ((char *) parent, W_OK|X_OK) == 0)
-       ret = mkdir ((char *) dir, 0777) == 0;
-    else if (access ((char *) parent, F_OK) == -1)
-       ret = FcMakeDirectory (parent) && (mkdir ((char *) dir, 0777) == 0);
-    else
-       ret = FcFalse;
-    FcStrFree (parent);
-    return ret;
+    FcCache *new;
+    FcFontSet *set = FcFontSetDeserialize (FcCacheSet (cache));
+    const FcChar8 *dir = FcCacheDir (cache);
+
+    new = FcDirCacheBuild (set, dir, dir_stat, dirs);
+    FcFontSetDestroy (set);
+
+    return new;
 }
 
 /* write serialized state to the cache file */
 FcBool
-FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *config)
+FcDirCacheWrite (FcCache *cache, FcConfig *config)
 {
+    FcChar8        *dir = FcCacheDir (cache);
     FcChar8        cache_base[CACHEBASE_LEN];
     FcChar8        *cache_hashed;
     int            fd;
     FcAtomic       *atomic;
-    FcCache        *cache;
     FcStrList      *list;
     FcChar8        *cache_dir = NULL;
-    FcChar8        *test_dir;
+    FcChar8        *test_dir, *d = NULL;
+    FcCacheSkip     *skip;
+    struct stat     cache_stat;
+    unsigned int    magic;
+    int                    written;
+    const FcChar8   *sysroot = FcConfigGetSysRoot (config);
 
     /*
      * Write it to the first directory in the list which is writable
      */
-    
+
     list = FcStrListCreate (config->cacheDirs);
     if (!list)
        return FcFalse;
-    while ((test_dir = FcStrListNext (list))) {
-       if (access ((char *) test_dir, W_OK|X_OK) == 0)
+    while ((test_dir = FcStrListNext (list)))
+    {
+       if (d)
+           FcStrFree (d);
+       if (sysroot)
+           d = FcStrBuildFilename (sysroot, test_dir, NULL);
+       else
+           d = FcStrCopyFilename (test_dir);
+
+       if (access ((char *) d, W_OK) == 0)
        {
-           cache_dir = test_dir;
+           cache_dir = FcStrCopyFilename (d);
            break;
        }
        else
@@ -566,28 +1031,38 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
            /*
             * If the directory doesn't exist, try to create it
             */
-           if (access ((char *) test_dir, F_OK) == -1) {
-               if (FcMakeDirectory (test_dir))
+           if (access ((char *) d, F_OK) == -1) {
+               if (FcMakeDirectory (d))
                {
-                   cache_dir = test_dir;
+                   cache_dir = FcStrCopyFilename (d);
+                   /* Create CACHEDIR.TAG */
+                   FcDirCacheCreateTagFile (d);
                    break;
                }
            }
+           /*
+            * Otherwise, try making it writable
+            */
+           else if (chmod ((char *) d, 0755) == 0)
+           {
+               cache_dir = FcStrCopyFilename (d);
+               /* Try to create CACHEDIR.TAG too */
+               FcDirCacheCreateTagFile (d);
+               break;
+           }
        }
     }
+    if (d)
+       FcStrFree (d);
     FcStrListDone (list);
     if (!cache_dir)
        return FcFalse;
 
     FcDirCacheBasename (dir, cache_base);
-    cache_hashed = FcStrPlus (cache_dir, cache_base);
+    cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL);
     if (!cache_hashed)
         return FcFalse;
-
-    cache = FcDirCacheProduce (set, dir, dirs);
-
-    if (!cache)
-       goto bail1;
+    FcStrFree (cache_dir);
 
     if (FcDebug () & FC_DBG_CACHE)
         printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n",
@@ -595,16 +1070,30 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
 
     atomic = FcAtomicCreate ((FcChar8 *)cache_hashed);
     if (!atomic)
-       goto bail2;
+       goto bail1;
 
     if (!FcAtomicLock (atomic))
        goto bail3;
 
-    fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
+    fd = FcOpen((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
     if (fd == -1)
        goto bail4;
-    
-    if (write (fd, cache, cache->size) != cache->size)
+
+    /* Temporarily switch magic to MMAP while writing to file */
+    magic = cache->magic;
+    if (magic != FC_CACHE_MAGIC_MMAP)
+       cache->magic = FC_CACHE_MAGIC_MMAP;
+
+    /*
+     * Write cache contents to file
+     */
+    written = write (fd, cache, cache->size);
+
+    /* Switch magic back */
+    if (magic != FC_CACHE_MAGIC_MMAP)
+       cache->magic = magic;
+
+    if (written != cache->size)
     {
        perror ("write cache");
        goto bail5;
@@ -613,7 +1102,29 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
     close(fd);
     if (!FcAtomicReplaceOrig(atomic))
         goto bail4;
-    FcStrFree ((FcChar8 *)cache_hashed);
+
+    /* If the file is small, update the cache chain entry such that the
+     * new cache file is not read again.  If it's large, we don't do that
+     * such that we reload it, using mmap, which is shared across processes.
+     */
+    if (cache->size < FC_CACHE_MIN_MMAP && FcStat (cache_hashed, &cache_stat))
+    {
+       lock_cache ();
+       if ((skip = FcCacheFindByAddrUnlocked (cache)))
+       {
+           skip->cache_dev = cache_stat.st_dev;
+           skip->cache_ino = cache_stat.st_ino;
+           skip->cache_mtime = cache_stat.st_mtime;
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
+           skip->cache_mtime_nano = cache_stat.st_mtim.tv_nsec;
+#else
+           skip->cache_mtime_nano = 0;
+#endif
+       }
+       unlock_cache ();
+    }
+
+    FcStrFree (cache_hashed);
     FcAtomicUnlock (atomic);
     FcAtomicDestroy (atomic);
     return FcTrue;
@@ -624,13 +1135,245 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
     FcAtomicUnlock (atomic);
  bail3:
     FcAtomicDestroy (atomic);
- bail2:
-    free (cache);
  bail1:
-    FcStrFree ((FcChar8 *)cache_hashed);
+    FcStrFree (cache_hashed);
     return FcFalse;
 }
 
+FcBool
+FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
+{
+    DIR                *d;
+    struct dirent *ent;
+    FcChar8    *dir;
+    FcBool     ret = FcTrue;
+    FcBool     remove;
+    FcCache    *cache;
+    struct stat        target_stat;
+    const FcChar8 *sysroot;
+
+    /* FIXME: this API needs to support non-current FcConfig */
+    sysroot = FcConfigGetSysRoot (NULL);
+    if (sysroot)
+       dir = FcStrBuildFilename (sysroot, cache_dir, NULL);
+    else
+       dir = FcStrCopyFilename (cache_dir);
+    if (!dir)
+    {
+       fprintf (stderr, "Fontconfig error: %s: out of memory\n", cache_dir);
+       return FcFalse;
+    }
+    if (access ((char *) dir, W_OK) != 0)
+    {
+       if (verbose || FcDebug () & FC_DBG_CACHE)
+           printf ("%s: not cleaning %s cache directory\n", dir,
+                   access ((char *) dir, F_OK) == 0 ? "unwritable" : "non-existent");
+       goto bail0;
+    }
+    if (verbose || FcDebug () & FC_DBG_CACHE)
+       printf ("%s: cleaning cache directory\n", dir);
+    d = opendir ((char *) dir);
+    if (!d)
+    {
+       perror ((char *) dir);
+       ret = FcFalse;
+       goto bail0;
+    }
+    while ((ent = readdir (d)))
+    {
+       FcChar8 *file_name;
+       const FcChar8   *target_dir;
+
+       if (ent->d_name[0] == '.')
+           continue;
+       /* skip cache files for different architectures and */
+       /* files which are not cache files at all */
+       if (strlen(ent->d_name) != 32 + strlen ("-" FC_ARCHITECTURE FC_CACHE_SUFFIX) ||
+           strcmp(ent->d_name + 32, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX))
+           continue;
+
+       file_name = FcStrBuildFilename (dir, (FcChar8 *)ent->d_name, NULL);
+       if (!file_name)
+       {
+           fprintf (stderr, "Fontconfig error: %s: allocation failure\n", dir);
+           ret = FcFalse;
+           break;
+       }
+       remove = FcFalse;
+       cache = FcDirCacheLoadFile (file_name, NULL);
+       if (!cache)
+       {
+           if (verbose || FcDebug () & FC_DBG_CACHE)
+               printf ("%s: invalid cache file: %s\n", dir, ent->d_name);
+           remove = FcTrue;
+       }
+       else
+       {
+           FcChar8 *s;
+
+           target_dir = FcCacheDir (cache);
+           if (sysroot)
+               s = FcStrBuildFilename (sysroot, target_dir, NULL);
+           else
+               s = FcStrdup (target_dir);
+           if (stat ((char *) s, &target_stat) < 0)
+           {
+               if (verbose || FcDebug () & FC_DBG_CACHE)
+                   printf ("%s: %s: missing directory: %s \n",
+                           dir, ent->d_name, s);
+               remove = FcTrue;
+           }
+           FcDirCacheUnload (cache);
+           FcStrFree (s);
+       }
+       if (remove)
+       {
+           if (unlink ((char *) file_name) < 0)
+           {
+               perror ((char *) file_name);
+               ret = FcFalse;
+           }
+       }
+        FcStrFree (file_name);
+    }
+
+    closedir (d);
+  bail0:
+    FcStrFree (dir);
+
+    return ret;
+}
+
+int
+FcDirCacheLock (const FcChar8 *dir,
+               FcConfig      *config)
+{
+    FcChar8 *cache_hashed = NULL;
+    FcChar8 cache_base[CACHEBASE_LEN];
+    FcStrList *list;
+    FcChar8 *cache_dir;
+    const FcChar8 *sysroot = FcConfigGetSysRoot (config);
+    int fd = -1;
+
+    FcDirCacheBasename (dir, cache_base);
+    list = FcStrListCreate (config->cacheDirs);
+    if (!list)
+       return -1;
+
+    while ((cache_dir = FcStrListNext (list)))
+    {
+       if (sysroot)
+           cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL);
+       else
+           cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL);
+       if (!cache_hashed)
+           break;
+       fd = FcOpen ((const char *)cache_hashed, O_RDWR);
+       FcStrFree (cache_hashed);
+       /* No caches in that directory. simply retry with another one */
+       if (fd != -1)
+       {
+#if defined(_WIN32)
+           if (_locking (fd, _LK_LOCK, 1) == -1)
+               goto bail;
+#else
+           struct flock fl;
+
+           fl.l_type = F_WRLCK;
+           fl.l_whence = SEEK_SET;
+           fl.l_start = 0;
+           fl.l_len = 0;
+           fl.l_pid = getpid ();
+           if (fcntl (fd, F_SETLKW, &fl) == -1)
+               goto bail;
+#endif
+           break;
+       }
+    }
+    FcStrListDone (list);
+    return fd;
+bail:
+    FcStrListDone (list);
+    if (fd != -1)
+       close (fd);
+    return -1;
+}
+
+void
+FcDirCacheUnlock (int fd)
+{
+    if (fd != -1)
+    {
+#if defined(_WIN32)
+       _locking (fd, _LK_UNLCK, 1);
+#else
+       struct flock fl;
+
+       fl.l_type = F_UNLCK;
+       fl.l_whence = SEEK_SET;
+       fl.l_start = 0;
+       fl.l_len = 0;
+       fl.l_pid = getpid ();
+       fcntl (fd, F_SETLK, &fl);
+#endif
+       close (fd);
+    }
+}
+
+/*
+ * Hokey little macro trick to permit the definitions of C functions
+ * with the same name as CPP macros
+ */
+#define args1(x)           (x)
+#define args2(x,y)         (x,y)
+
+const FcChar8 *
+FcCacheDir args1(const FcCache *c)
+{
+    return FcCacheDir (c);
+}
+
+FcFontSet *
+FcCacheCopySet args1(const FcCache *c)
+{
+    FcFontSet  *old = FcCacheSet (c);
+    FcFontSet  *new = FcFontSetCreate ();
+    int                i;
+
+    if (!new)
+       return NULL;
+    for (i = 0; i < old->nfont; i++)
+    {
+       FcPattern   *font = FcFontSetFont (old, i);
+       
+       FcPatternReference (font);
+       if (!FcFontSetAdd (new, font))
+       {
+           FcFontSetDestroy (new);
+           return NULL;
+       }
+    }
+    return new;
+}
+
+const FcChar8 *
+FcCacheSubdir args2(const FcCache *c, int i)
+{
+    return FcCacheSubdir (c, i);
+}
+
+int
+FcCacheNumSubdir args1(const FcCache *c)
+{
+    return c->dirs_count;
+}
+
+int
+FcCacheNumFont args1(const FcCache *c)
+{
+    return FcCacheSet(c)->nfont;
+}
+
 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest. This code was
@@ -685,7 +1428,7 @@ static void MD5Init(struct MD5Context *ctx)
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
-static void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned len)
+static void MD5Update(struct MD5Context *ctx, const unsigned char *buf, unsigned len)
 {
     FcChar32 t;
 
@@ -730,7 +1473,7 @@ static void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned len)
 }
 
 /*
- * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 static void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
@@ -771,7 +1514,7 @@ static void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
     MD5Transform(ctx->buf, (FcChar32 *) ctx->in);
     byteReverse((unsigned char *) ctx->buf, 4);
     memcpy(digest, ctx->buf, 16);
-    memset(ctx, 0, sizeof(ctx));        /* In case it's sensitive */
+    memset(ctx, 0, sizeof(*ctx));        /* In case it's sensitive */
 }
 
 
@@ -874,3 +1617,96 @@ static void MD5Transform(FcChar32 buf[4], FcChar32 in[16])
     buf[2] += c;
     buf[3] += d;
 }
+
+FcBool
+FcDirCacheCreateTagFile (const FcChar8 *cache_dir)
+{
+    FcChar8            *cache_tag;
+    int                 fd;
+    FILE               *fp;
+    FcAtomic           *atomic;
+    static const FcChar8 cache_tag_contents[] =
+       "Signature: 8a477f597d28d172789f06886806bc55\n"
+       "# This file is a cache directory tag created by fontconfig.\n"
+       "# For information about cache directory tags, see:\n"
+       "#       http://www.brynosaurus.com/cachedir/\n";
+    static size_t       cache_tag_contents_size = sizeof (cache_tag_contents) - 1;
+    FcBool              ret = FcFalse;
+
+    if (!cache_dir)
+       return FcFalse;
+
+    if (access ((char *) cache_dir, W_OK) == 0)
+    {
+       /* Create CACHEDIR.TAG */
+       cache_tag = FcStrBuildFilename (cache_dir, "CACHEDIR.TAG", NULL);
+       if (!cache_tag)
+           return FcFalse;
+       atomic = FcAtomicCreate ((FcChar8 *)cache_tag);
+       if (!atomic)
+           goto bail1;
+       if (!FcAtomicLock (atomic))
+           goto bail2;
+       fd = FcOpen((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0644);
+       if (fd == -1)
+           goto bail3;
+       fp = fdopen(fd, "wb");
+       if (fp == NULL)
+           goto bail3;
+
+       fwrite(cache_tag_contents, cache_tag_contents_size, sizeof (FcChar8), fp);
+       fclose(fp);
+
+       if (!FcAtomicReplaceOrig(atomic))
+           goto bail3;
+
+       ret = FcTrue;
+      bail3:
+       FcAtomicUnlock (atomic);
+      bail2:
+       FcAtomicDestroy (atomic);
+      bail1:
+       FcStrFree (cache_tag);
+    }
+
+    if (FcDebug () & FC_DBG_CACHE)
+    {
+       if (ret)
+           printf ("Created CACHEDIR.TAG at %s\n", cache_dir);
+       else
+           printf ("Unable to create CACHEDIR.TAG at %s\n", cache_dir);
+    }
+
+    return ret;
+}
+
+void
+FcCacheCreateTagFile (const FcConfig *config)
+{
+    FcChar8   *cache_dir = NULL, *d = NULL;
+    FcStrList *list;
+    const FcChar8 *sysroot = FcConfigGetSysRoot (config);
+
+    list = FcConfigGetCacheDirs (config);
+    if (!list)
+       return;
+
+    while ((cache_dir = FcStrListNext (list)))
+    {
+       if (d)
+           FcStrFree (d);
+       if (sysroot)
+           d = FcStrBuildFilename (sysroot, cache_dir, NULL);
+       else
+           d = FcStrCopyFilename (cache_dir);
+       if (FcDirCacheCreateTagFile (d))
+           break;
+    }
+    if (d)
+       FcStrFree (d);
+    FcStrListDone (list);
+}
+
+#define __fccache__
+#include "fcaliastail.h"
+#undef __fccache__